def socket_thread_function(self, name):
self._logger.info("Setting up socket")
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.bind((socket.gethostname(), 42069))
self.sock.listen()
self.sock.settimeout(None)
while True:
self._logger.info("Waiting for connection")
connection, _client_address = self.sock.accept()
connection.settimeout(None)
self.connection = connection
self._logger.info("Connection established")
url = self._settings.get(["url"])
if url:
self._logger.info("URL Configured")
term = (erlang.OtpErlangAtom(bytes("url", "utf-8")),
erlang.OtpErlangBinary(bytes(url, "utf-8")))
self.queue.put(term)
try:
for data in self.recv_loop(connection):
if data[0] == erlang.OtpErlangAtom(bytes(
"logger", "utf-8")):
self.handle_erlang_log(data[1], data[2])
elif data[0] == erlang.OtpErlangAtom(b'ping'):
self.last_ping = datetime.datetime.now().isoformat()
self.send(erlang.OtpErlangAtom(b'pong'), connection)
elif data[0] == erlang.OtpErlangAtom(
b'phoenix_socket_connection'):
self.phoenix_socket_connection = data[1].value.decode()
else:
self._logger.error("unhandled message=" + str(data))
except (OSError):
pass
def test_term_to_binary_atom(self):
self.assertEqual(b'\x83s\0',
erlang.term_to_binary(erlang.OtpErlangAtom(b'')))
self.assertEqual(
b'\x83s\4test',
erlang.term_to_binary(erlang.OtpErlangAtom(b'test'))
)
def test_binary_to_term_atom(self):
self.assertRaises(erlang.ParseException, erlang.binary_to_term,
b'\x83d')
self.assertRaises(erlang.ParseException, erlang.binary_to_term,
b'\x83d\0')
self.assertRaises(erlang.ParseException, erlang.binary_to_term,
b'\x83d\0\1')
self.assertEqual(erlang.OtpErlangAtom(b''),
erlang.binary_to_term(b'\x83d\0\0'))
self.assertEqual(erlang.OtpErlangAtom(b''),
erlang.binary_to_term(b'\x83s\0'))
self.assertEqual(erlang.OtpErlangAtom(b'test'),
erlang.binary_to_term(b'\x83d\0\4test'))
self.assertEqual(erlang.OtpErlangAtom(b'test'),
erlang.binary_to_term(b'\x83s\4test'))
def handle_erlang_log(self, level, content):
if not isinstance(content, erlang.OtpErlangBinary):
self._logger.error("unexpected content " + str(content))
return
if level == erlang.OtpErlangAtom(b'debug'):
self._logger.debug(content.value.decode())
elif level == erlang.OtpErlangAtom(b'info'):
self._logger.info(content.value.decode())
elif level == erlang.OtpErlangAtom(b'warn'):
self._logger.warning(content.value.decode())
elif level == erlang.OtpErlangAtom(b'error'):
self._logger.error(content.value.decode())
else:
self._logger.error("unknown erlang logging level: " + str(level))
def test_binary_to_term_improper_list(self):
self.assertRaises(erlang.ParseException, erlang.binary_to_term,
b'\x83l\0\0\0\0k')
lst = erlang.binary_to_term(b'\x83l\0\0\0\1jd\0\4tail')
self.assertEqual(erlang.OtpErlangList, type(lst))
self.assertEqual([[], erlang.OtpErlangAtom(b'tail')], lst.value)
self.assertEqual(True, lst.improper)
def on_settings_save(self, data):
old_url = self._settings.get(["url"])
octoprint.plugin.SettingsPlugin.on_settings_save(self, data)
new_url = self._settings.get(["url"])
if old_url != new_url:
self._logger.info(
"url changed from {old_url} to {new_url}".format(**locals()))
term = (erlang.OtpErlangAtom(bytes("url", "utf-8")),
erlang.OtpErlangBinary(bytes(new_url, "utf-8")))
self.send(term, self.connection)
def send_cmd(name, cmd):
# REG_SEND control message
ctrl_msg = (6,
erl.OtpErlangPid(erl.OtpErlangAtom(name), '\x00\x00\x00\x03',
'\x00\x00\x00\x00', '\x00'),
erl.OtpErlangAtom(''), erl.OtpErlangAtom('rex'))
msg = (erl.OtpErlangPid(erl.OtpErlangAtom(name), '\x00\x00\x00\x03',
'\x00\x00\x00\x00', '\x00'),
(erl.OtpErlangAtom('call'), erl.OtpErlangAtom('os'),
erl.OtpErlangAtom('cmd'), [cmd], erl.OtpErlangAtom('user')))
new_data = '\x70' + erl.term_to_binary(ctrl_msg) + erl.term_to_binary(msg)
return pack('!I', len(new_data)) + new_data
def test_atom(self):
atom1 = erlang.OtpErlangAtom('test')
self.assertEqual(erlang.OtpErlangAtom, type(atom1))
self.assertEqual(erlang.OtpErlangAtom('test'), atom1)
self.assertEqual("OtpErlangAtom('test')", repr(atom1))
self.assertTrue(type(atom1) is erlang.OtpErlangAtom)
atom2 = erlang.OtpErlangAtom('test2')
atom1_new = erlang.OtpErlangAtom('test')
self.assertFalse(atom1 is atom2)
self.assertNotEqual(hash(atom1), hash(atom2))
self.assertFalse(atom1 is atom1_new)
self.assertEqual(hash(atom1), hash(atom1_new))
self.assertEqual('X' * 255, erlang.OtpErlangAtom('X' * 255).value)
self.assertEqual('X' * 256, erlang.OtpErlangAtom('X' * 256).value)
def test_invalid_atom(self):
self.assertRaises(erlang.OutputException, erlang.OtpErlangAtom.binary,
erlang.OtpErlangAtom([1, 2]))
def test_binary_to_term_predefined_atoms(self):
self.assertEqual(True, erlang.binary_to_term(b'\x83s\4true'))
self.assertEqual(False, erlang.binary_to_term(b'\x83s\5false'))
self.assertEqual(erlang.OtpErlangAtom(b'undefined'),
erlang.binary_to_term(b'\x83d\0\11undefined'))
def on_print_progress(self, storage, path, progress):
term = (erlang.OtpErlangAtom(b'progress'),
erlang.OtpErlangBinary(bytes(storage, "utf-8")),
erlang.OtpErlangBinary(bytes(path, "utf-8")), progress)
self.send(term, self.connection)
import erlang, os, struct
ATOM_BUFFER_BOTH = erlang.OtpErlangAtom(b'buffer_both')
def send(term, stream):
"""Write an Erlang term to an output stream."""
payload = erlang.term_to_binary(term)
header = struct.pack('!I', len(payload))
stream.write(header)
stream.write(payload)
stream.flush()
def recv(stream):
"""Read an Erlang term from an input stream."""
header = stream.read(4)
if len(header) != 4:
return None # EOF
(length, ) = struct.unpack('!I', header)
payload = stream.read(length)
if len(payload) != length:
return None
term = erlang.binary_to_term(payload)
return term
def recv_loop(stream):
"""Yield Erlang terms from an input stream."""
message = recv(stream)
while message:
# gray_img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
gray_img = img
faces = face_cascade.detectMultiScale(gray_img)
# print(faces)
# draw rectangle around the cars
for (x, y, w, h) in faces:
cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
cv2.putText(img, 'face', (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.7,
(0, 255, 0), 2)
cv2.imshow("detected", img)
cv2.waitKey(1)
return img
if __name__ == '__main__':
input, output = os.fdopen(3, 'rb'), os.fdopen(4, 'wb')
for data in ErlCmd.recv_loop(input):
if data[0] == ErlCmd.ATOM_BUFFER_BOTH:
# image = Image.frombuffer("RGB", (640, 480), data[1].value, 'raw', "RGB", 0, 1)
# image = Image.frombuffer("L", (640, 480), data[1].value, 'raw', "L", 0, 1)
image = Image.frombuffer("L", (640, 480), data[2].value, 'raw',
"L", 0, 1)
image = np.array(image)
image = detectObjects(image)
# _, image = cv2.imencode('.jpeg', image)
# print(image)
term = erlang.OtpErlangAtom(b'test')
# term = erlang.OtpErlangBinary(image.tobytes())
ErlCmd.send(term, output)
