script = GifConverter(ffmpeg_bin, out_dir)
while self.running():
with self.filters_lock:
script.change_settings(\
self.get_parameter("smudge_length"),
self.get_parameter("smudge_opacity") )
data = video_input.read()
print data
try:
data = json.loads(data)
req_keys = ['path', 'w', 'h', 'frames']
if not all(k in data for k in req_keys):
raise Exception('Incorrect json keys')
# print '>> OK !'
file_path, w, h, frames = data['path'], int(data['w']), int(
data['h']), int(data['frames'])
print[file_path, w, h, frames]
script(file_path, w, h, frames)
except Exception as e:
print 'Read/parse error %s: "%s"' % (type(e), e)
if __name__ == "__main__":
if len(sys.argv) < 2:
print 'Please provide ffmpeg executable path as first argument'
exit()
config_name = os.path.join(os.path.dirname(__file__), "service.json")
sc = ServiceController(GifConvertService, config_name)
sc.start()
def declare_inputs(self):
"""deklaracja wejść"""
#deklaracja wejścia "videoInput" będącego interfejsem wyjściowym konektora msg_stream_connector
self.declare_input("videoInput", InputMessageConnector(self))
def run(self):
"""główna metoda usługi"""
video_input = self.get_input(
"videoInput") #obiekt interfejsu wejściowego
video_output = self.get_output(
"videoOutput") #obiekt interfejsu wyjściowego
#pętla główna usługi
while self.running():
frame_obj = video_input.read(
) #odebranie danych z interfejsu wejściowego
frame = np.loads(frame_obj) #załadowanie ramki do obiektu NumPy
frame_luv = cv2.cvtColor(frame, cv2.COLOR_RGB2LUV)
video_output.send(frame_luv.dumps(
)) #przesłanie ramki za pomocą interfejsu wyjściowego
if __name__ == "__main__":
#utworzenie obiektu kontrolera usługi
config_name = os.path.join(
os.path.dirname(__file__),
"service.json") # f.e. src\mark_frame_service\service.json
sc = ServiceController(ColorspaceToLuvService, config_name)
sc.start() #uruchomienie usługi
) #uruchomienie wątku obsługującego strumień sterujący
video_input = self.get_input(
"videoInput") #obiekt interfejsu wejściowego
video_output_master = self.get_output(
"videoOutputMaster") #obiekt interfejsu wyjściowego
video_output_output = self.get_output(
"videoOutputOutput") #obiekt interfejsu wyjściowego
while self.running(): #pętla główna usługi
frame_obj = video_input.read(
) #odebranie danych z interfejsu wejściowego
frame = np.loads(frame_obj) # załadowanie ramki do obiektu NumPy
frame = cv2.flip(frame, 1) # odwrócenie ramki w poziomie
frame = cv2.cvtColor(
frame, cv2.COLOR_BGR2RGBA) # przywrocenie naturalnych kolorów
frame = frame.dumps()
video_output_output.send(frame) # przesłąnie obrazu na wyjście
video_output_master.send(
frame
) # przesłanie obrazu do mastera do kolejnego przetwarzania
if __name__ == "__main__":
sc = ServiceController(
PreprocessingService,
"preprocessingService.json") #utworzenie obiektu kontrolera usługi
sc.start() #uruchomienie usługi
) #odebranie danych z interfejsu wejściowego
self.frame = np.loads(
frame_obj) #załadowanie ramki do obiektu NumPy
if self.authorization == 1:
# Detect faces in the image
faces = self.faceCascade.detectMultiScale(
self.frame,
scaleFactor=1.2,
minNeighbors=5,
minSize=(100, 100),
flags=cv2.cv.CV_HAAR_SCALE_IMAGE)
if len(faces) > 0:
self.face = faces[0]
(x, y, w, h) = self.face
cv2.rectangle(self.frame, (x, y), (x + w, y + h),
(0, 255, 0), 2)
else:
self.face = None
video_output.send(self.frame.dumps(
)) #przesłanie ramki za pomocą interfejsu wyjściowego
if __name__ == "__main__":
sc = ServiceController(
FaceRecognitionService,
"face_recognition.json") #utworzenie obiektu kontrolera usługi
sc.start() #uruchomienie usługi
frame = np.loads(frame_obj)
# resize
frame_resized = FrameResizeService.__resize_frame(
frame, self.thumb_width)
video_output_resized.send(frame_resized.dumps())
self.__debug_loop_iterations()
@log_called_times_decorator
def __debug_loop_iterations(self):
pass
@staticmethod
def __resize_frame(frame, expected_w):
h, width, channels = frame.shape
scale_factor = expected_w * 1.0 / width
frame_thumb = cv2.resize(frame,
dsize=(0, 0),
fx=scale_factor,
fy=scale_factor,
interpolation=cv2.INTER_CUBIC)
return frame_thumb
if __name__ == "__main__":
config_name = os.path.join(
os.path.dirname(__file__),
"service.json") # f.e. src\mark_frame_service\service.json
sc = ServiceController(FrameResizeService, config_name)
sc.start()
) # pobieram obiekt interfejsu wyjściowego dla obrazu
try:
video_output.send(frame.dumps(
)) # przesłanie danych za pomocą interfejsu wyjściowego
except:
video_output.close(
) # zamknięcie socketa - będzie odtworzone w kolejnej próbie (jak wyżej)
def run(self): # główna metoda usługi
# Uruchamiam w odzielnych wątkach metody obsługujące wejścia i wyjścia serwisów podrzędnych, które podłączone są do mastera
for service_name in self.service_params.getAllServiceNames():
input_settings_connector = self.service_params.getInputSettingsConnectorName(
service_name
) # pobieram nazwę konektora wejściowego serwisu podrzędnego (wejście ustawień)
input_video_connector = self.service_params.getInputVideoConnectorName(
service_name
) # pobieram nazwę konektora wejściowego serwisu podrzędnego (wejście obrazu)
threading.Thread(target=lambda: self.watch_services(
input_settings_connector, input_video_connector
)).start(
) #uruchomienie wątku obsługującego wejścia i wyjścia dla serwisu podrzędnego
while self.running():
None
if __name__ == "__main__":
sc = ServiceController(
MasterService,
"masterService.json") #utworzenie obiektu kontrolera usługi
sc.start() #uruchomienie usługi
from MySniffer import Tcp, start_sniffing
class MySnifferService(Service):
def one_each_tcp_packet(self, data):
output_msg = self.get_output('SniffService')
output_msg.my_send(data)
def run(self):
print('run')
""" :type: MyOutputObjectConnector """
start_sniffing(self.one_each_tcp_packet)
# output_msg.my_send(post_fields)
def declare_inputs(self):
pass
def declare_outputs(self):
print('declare_outputs')
self.declare_output('SniffService', MyOutputObjectConnector(self))
def __init__(self):
print('=============== Start sniff service ===============')
Service.__init__(self)
if __name__ == "__main__":
sc = ServiceController(MySnifferService, "service.json")
sc.start()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import InputMessageConnector, OutputMessageConnector
from ComssServiceDevelopment.service import Service, ServiceController
import dpkt
import socket
class EndService(Service):
def run(self):
while True:
print self.get_input("testInput").read()
def declare_inputs(self):
self.declare_input("testInput", InputMessageConnector(self))
def declare_outputs(self):
pass
if __name__ == "__main__":
print "starting"
sc = ServiceController(EndService, "consumer.json")
sc.start()
video_input = self.get_input("videoInput")
video_output_resized = self.get_output("videoOutputResized")
self.thumb_width = self.get_parameter("out_width")
print "thumb width: " +str(self.thumb_width) + str(type(self.thumb_width))
while self.running():
# read frame object
frame_obj = video_input.read()
frame = np.loads(frame_obj)
# resize
frame_resized = FrameResizeService.__resize_frame(frame, self.thumb_width)
video_output_resized.send(frame_resized.dumps())
self.__debug_loop_iterations()
@log_called_times_decorator
def __debug_loop_iterations(self):
pass
@staticmethod
def __resize_frame(frame, expected_w):
h, width, channels = frame.shape
scale_factor = expected_w * 1.0 / width
frame_thumb = cv2.resize( frame, dsize=(0,0), fx=scale_factor, fy=scale_factor, interpolation=cv2.INTER_CUBIC)
return frame_thumb
if __name__=="__main__":
config_name = os.path.join( os.path.dirname(__file__), "service.json") # f.e. src\mark_frame_service\service.json
sc = ServiceController(FrameResizeService, config_name)
sc.start()
photos_recognized_output.send(len(self.photos))
# photos_output.send(photo.dumps())
else:
counter = Counter(self.photos)
most_common = [el for el, count in counter.most_common(1)][0]
ratio = self.photos.count(most_common)/self.photos_count;
if ratio > 0.6:
print ("sending " + most_common)
user_output.send(most_common)
else:
user_output.send("UNKNOWN")
print str(len(self.photos)), str(self.photos_count)
def run(self): #główna metoda usługi
threading.Thread(target=self.watch_authorization).start()
threading.Thread(target=self.watch_photos).start() #uruchomienie wątku obsługującego strumień sterujący
video_input = self.get_input("videoInput") #obiekt interfejsu wejściowego
video_output = self.get_output("videoOutput") #obiekt interfejsu wyjściowego
while self.running(): #pętla główna usługi
frame_obj = video_input.read() #odebranie danych z interfejsu wejściowego
frame = np.loads(frame_obj) #załadowanie ramki do obiektu NumPy
video_output.send(frame.dumps()) #przesłanie ramki za pomocą interfejsu wyjściowego
if __name__=="__main__":
sc = ServiceController(FaceComparatorService, "face_comparator_service.json") #utworzenie obiektu kontrolera usługi
sc.start() #uruchomienie usługi
if type(msg) is str:
post_fields = self.my_password_finder.find_pass_in_http_message(
msg)
elif type(msg) is dict:
print msg
post_fields = self.my_password_finder.find_pass(msg)
if post_fields is not None:
print('MyPassFinderService:')
print(post_fields)
output_msg.my_send(post_fields)
def declare_inputs(self):
print('declare_inputs')
self.declare_input('In', MyInputObjectConnector(self))
def declare_outputs(self):
print('declare_outputs')
self.declare_output('StorageService', MyOutputObjectConnector(self))
def __init__(self):
print('=============== Start storage service ===============')
Service.__init__(self)
self.my_password_finder = MyPasswordFinder()
if __name__ == "__main__":
sc = ServiceController(MyPassFinderService, "service.json")
sc.start()
with self.filters_lock:
current_filters = self.get_parameter("filtersOn")
if 1 in current_filters:
# self.set_parameter("filtersOn", [])
self.update_parameters({"filtersOn": []}) # reset filters
self.last_rect_shown_time = time_now
self.__draw_rectangle(frame)
elif self.last_rect_shown_time and (
time_now - self.last_rect_shown_time) < RECT_DISPLAY_LEN:
self.__draw_rectangle(frame)
# forward
video_output.send(frame.dumps(
)) #przesłanie ramki za pomocą interfejsu wyjściowego
def __draw_rectangle(self, frame):
height, width, _ = frame.shape
overlay = frame.copy()
cv2.rectangle(overlay, (0, 0), (int(width * SIZE), int(height * SIZE)),
(255, 0, 0), -1)
cv2.addWeighted(overlay, OPACITY, frame, 1 - OPACITY, 0, frame)
if __name__ == "__main__":
#utworzenie obiektu kontrolera usługi
config_name = os.path.join(
os.path.dirname(__file__),
"service.json") # f.e. src\mark_frame_service\service.json
sc = ServiceController(MarkFrameService, config_name)
sc.start() #uruchomienie usługi
# -*- coding: utf-8 -*-
from ComssServiceDevelopment.connectors.tcp.msg_stream_connector import InputMessageConnector, OutputMessageConnector
from ComssServiceDevelopment.service import Service, ServiceController
import dpkt
import socket
class TCP_Reassembler(Service):
def run(self):
output = self.get_output("tcpOutput")
while True:
buf = self.get_input("tcpInput").read()
e = dpkt.ethernet.Ethernet(buf)
ip=e.data
tcp=ip.data
tcp.seq
print tcp.seq
output.send(str(buf))
def declare_inputs(self):
self.declare_input("tcpInput", InputMessageConnector(self))
def declare_outputs(self):
self.declare_output("tcpOutput", OutputMessageConnector(self))
if __name__=="__main__":
sc = ServiceController(TCP_Reassembler, "tcp_reassembler.json")
sc.start()
def run(self):
print('run')
input_msg = self.get_input('In')
""" :type: MyInputObjectConnector """
exception = False
while self.running() and not exception:
msg = input_msg.my_read()
print("StorageService:")
print(msg)
# print(msg)
self.storage.append_to_file(msg)
def declare_inputs(self):
print('declare_inputs')
self.declare_input('In', MyInputObjectConnector(self))
def declare_outputs(self):
print('declare_outputs')
pass
def __init__(self):
print('=============== Start storage service ===============')
Service.__init__(self)
self.storage = Storage()
if __name__ == "__main__":
sc = ServiceController(StorageService, "service.json")
sc.start()
def process_frame(self, frame):
image = Image.fromarray(frame)
enhancer = ImageEnhance.Brightness(image)
factor = self.get_brightness_factor()
image = enhancer.enhance(factor)
frame = np.array(image)
return frame
def get_brightness_factor(self):
brightness_index = self.this_settings["brightnessIndex"]
min_index = self.this_settings["minBrightnessIndex"]
max_index = self.this_settings["maxBrightnessIndex"]
if brightness_index < 0:
return -1/min_index*brightness_index + 1
else:
a = 0.985
f = lambda x: (x/math.sqrt(1-math.pow(x,2)))
return f(brightness_index/max_index*a)/f(a)*14+1
def run(self): #główna metoda usługi
threading.Thread(target=self.read_settings).start()
threading.Thread(target=self.read_video).start()
threading.Thread(target=self.send_settings).start()
self.send_video()
if __name__=="__main__":
sc = ServiceController(BrightnessService, "brightnessService.json") #utworzenie obiektu kontrolera usługi
sc.start() #uruchomienie usługi
def declare_outputs(self):
self.declare_output("out1", OutputMessageConnector(self))
self.declare_output("out2", OutputMessageConnector(self))
def declare_inputs(self):
self.declare_input("videoInput", InputMessageConnector(self))
def run(self):
video_input = self.get_input("videoInput")
out1 = self.get_output("out1")
out2 = self.get_output("out2")
while self.running():
frame_obj = video_input.read()
frame = np.loads(frame_obj)
out1.send(frame.dumps())
out2.send(frame.dumps())
if __name__ == "__main__":
if len(sys.argv) < 2:
print "Please provide config file as first and only argument"
exit(1)
cfg_file = sys.argv[1]
config_name = os.path.join(os.path.dirname(__file__), cfg_file)
sc = ServiceController(DemultiplexerService, config_name)
sc.start()
audio_output = self.get_output(
"audioOutput") #obiekt interfejsu wyjściowego
while self.running(): #pętla główna usługi
try:
#################################################################
# na razie leci video, ma leciec audio!!!
#################################################################
frame_obj = audio_input.read(
) #odebranie danych z interfejsu wejściowego
except Exception as e:
audio_input.close()
audio_output.close()
break
frame = np.loads(frame_obj) #załadowanie ramki do obiektu NumPy
with self.filters_lock: #blokada wątku
current_filters = self.get_parameter(
"filtersOn") #pobranie wartości parametru "filtersOn"
############################################################
# tu mają być filtry audio
############################################################
audio_output.send(frame.dumps(
)) #przesłanie ramki za pomocą interfejsu wyjściowego
if __name__ == "__main__":
sc = ServiceController(
FilterAudioService,
"filter_audio_service.json") #utworzenie obiektu kontrolera usługi
sc.start() #uruchomienie usługi
for o, w in self.obj.iteritems():
print baza[unicode(o)]["stan_alarmowy"]
wynik[unicode(o)] = {}
wynik[unicode(o)][u"stan_początkowy"] = baza[unicode(
o)][u"stan_początkowy"]
wynik[unicode(o)][u"stan_alarmowy"] = baza[unicode(
o)][u"stan_alarmowy"]
wynik[unicode(o)][u"stan_krytyczny"] = baza[unicode(
o)][u"stan_krytyczny"]
wynik[unicode(o)][u"opady"] = round(w, 2)
predykcja = (w /
100) * 12 + baza[unicode(o)][u"stan_początkowy"]
wynik[unicode(o)][u"przewidywany_poziom"] = round(predykcja, 2)
if predykcja > baza[unicode(o)][u"stan_krytyczny"]:
wynik[unicode(o)][u"klasyfikacja"] = 3
elif predykcja > baza[unicode(o)][u"stan_alarmowy"]:
wynik[unicode(o)][u"klasyfikacja"] = 2
else:
wynik[unicode(o)][u"klasyfikacja"] = 1
wynik_output.send(
wynik) #przesłanie ramki za pomocą interfejsu wyjściowego
if __name__ == "__main__":
sc = ServiceController(
AlarmService,
"alarmService.json") #utworzenie obiektu kontrolera usługi
sc.start() #uruchomienie usługi
frame = frame.dumps()
with self.service_lock:
self.video_frame = frame
def send_video(self):
video_output = self.get_output(
"videoOutput") #obiekt interfejsu wyjściowego
while self.running():
if not self.video_frame is None:
video_output.send(
self.video_frame
) #przesłanie ramki za pomocą interfejsu wyjściowego
#print "ramka wysłana"
with self.service_lock:
self.video_frame = None
def process_frame(self, frame):
return cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # zastosowanie filtra
def run(self): #główna metoda usługi
threading.Thread(target=self.read_settings).start()
threading.Thread(target=self.read_video).start()
threading.Thread(target=self.send_settings).start()
self.send_video()
if __name__ == "__main__":
sc = ServiceController(
Filter1Service,
"filterGrayService.json") #utworzenie obiektu kontrolera usługi
sc.start() #uruchomienie usługi
imgTk = ImageTk.PhotoImage(image=img)
video_frame_label.imgTk = imgTk
video_frame_label.configure(image=imgTk)
def run(self): #główna metoda usługi
threading.Thread(target=self.run_app_gui).start(
) # uruchomienie wątku obsługującego panel GUI
video_input_origin = self.get_input(
"videoInputOrigin"
) # obiekt interfejsu wyjściowego dla obrazu oryginalnego
video_input_modified = self.get_input(
"videoInputModified"
) # obiekt interfejsu wyjściowego dla obrazu zmodyfikowanego
while self.running(): # pętla główna usługi
try:
self.show_frame(video_input_modified,
self.app.label_videoModified
) # wyświetlenie obrazu przetworzonego
self.show_frame(video_input_origin, self.app.label_videoOrigin
) # wyświetlenie obrazu zmodyfikowanego
except:
pass
if __name__ == "__main__":
sc = ServiceController(
OutputService,
"outputService.json") #utworzenie obiektu kontrolera usługi
sc.start() #uruchomienie usługi
if 'Content-Encoding' not in h.fields \
and h.fields['Content-Type'] == "application/x-www-form-urlencoded":
print HeaderParser.data_to_string(msg['data'])
output_msg.my_send({
'header':
msg['header'], # raw header
'fields':
h.fields, # header fields
'request_line':
h.request_line, # request line
'data':
HeaderParser.data_to_string(msg['data']) # data
})
def declare_inputs(self):
print('declare_inputs')
self.declare_input('In', MyInputObjectConnector(self))
def declare_outputs(self):
print('declare_outputs')
self.declare_output('Out', MyOutputObjectConnector(self))
def __init__(self):
print('=============== Start SelectorService ===============')
Service.__init__(self)
if __name__ == "__main__":
sc = ServiceController(SelectorService, "service.json")
sc.start()
input_start = True
out = None
while self.running(): #pętla główna usługi
try:
#################################################################
# na razie leci video, ma leciec audio!!!
#################################################################
frame_obj = audio_input.read(
) #odebranie danych z interfejsu wejściowego
except Exception as e:
audio_input.close()
if out != None:
out.release()
break
if input_start:
#######################################################
# tu inicjalizacja pliku do zapisu
#######################################################
input_start = False
###########################################################
# tu zapisywanie audio
###########################################################
if __name__ == "__main__":
sc = ServiceController(
SaveVideoService,
"save_audio_service.json") #utworzenie obiektu kontrolera usługi
sc.start() #uruchomienie usługi
class MyPrinter(Service):
def declare_outputs(self):
pass
def run(self):
print('run')
input_msg = self.get_input('In')
""" :type: MyInputObjectConnector """
while self.running():
print('running')
try:
msg = input_msg.read()
# print(input_msg.socket_connection.gethostname())
print(msg)
except Exception as e:
print(e)
input_msg.reopen_input()
def declare_inputs(self):
self.declare_input('In', MyInputObjectConnector(self))
if __name__ == "__main__":
sc = ServiceController(MyPrinter, "service.json")
sc.start()
while self.running(): #pętla główna usługi
try:
frame_obj = video_input.read() #odebranie danych z interfejsu wejściowego
except Exception as e:
video_input.close()
video_output.close()
break
frame = np.loads(frame_obj) #załadowanie ramki do obiektu NumPy
with self.filters_lock: #blokada wątku
current_filters = self.get_parameter("filtersOn") #pobranie wartości parametru "filtersOn"
if 1 in current_filters: #sprawdzenie czy parametr "filtersOn" ma wartość 1, czyli czy ma być stosowany filtr
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) #zastosowanie filtru COLOR_BGR2GRAY z biblioteki OpenCV na ramce wideo
frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR) # by można było zapisać jako obraz kolorowy
if 2 in current_filters:
frame = cv2.blur(frame,(7,7))
if 3 in current_filters:
frame = cv2.GaussianBlur(frame,(5,5),0)
if 4 in current_filters:
frame = cv2.medianBlur(frame,9) ## nieparzysta liczba
video_output.send(frame.dumps()) #przesłanie ramki za pomocą interfejsu wyjściowego
if __name__=="__main__":
sc = ServiceController(FilterAudioService, "filter_video_service.json") #utworzenie obiektu kontrolera usługi
sc.start() #uruchomienie usługi
class TCP_Splitter(Service):
def run(self):
output = self.get_output("tcpOutput")
while True:
buf = self.get_input("pcapInput").read()
e = dpkt.ethernet.Ethernet(buf)
if e.type != dpkt.ethernet.ETH_TYPE_IP:
continue
ip = e.data
if ip.p not in (dpkt.ip.IP_PROTO_TCP, dpkt.ip.IP_PROTO_UDP):
continue
tcp = ip.data
src = socket.inet_ntoa(ip.src)
dst = socket.inet_ntoa(ip.dst)
print "%s -> %s" % (src, dst)
print "port: %s -> %s" % (tcp.sport, tcp.dport)
output.send(str(e))
def declare_inputs(self):
self.declare_input("pcapInput", InputMulticastConnector(self))
def declare_outputs(self):
self.declare_output("tcpOutput", OutputMessageConnector(self))
if __name__ == "__main__":
sc = ServiceController(TCP_Splitter, "tcp_splitter.json")
sc.start()
video_input = self.get_input(
"videoInput") #obiekt interfejsu wejściowego
video_output = self.get_output(
"videoOutput") #obiekt interfejsu wyjściowego
while self.running(): #pętla główna usługi
frame_obj = video_input.read(
) #odebranie danych z interfejsu wejściowego
frame = np.loads(frame_obj) #załadowanie ramki do obiektu NumPy
with self.service_lock: # blokada wątku
resize_coeff = self.resize_coeff
frame = cv2.resize(frame,
None,
fx=resize_coeff,
fy=resize_coeff,
interpolation=cv2.INTER_AREA)
#frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA)
video_output.send(frame.dumps(
)) #przesłanie ramki za pomocą interfejsu wyjściowego
if __name__ == "__main__":
sc = ServiceController(
ResizeService,
"resizeService.json") #utworzenie obiektu kontrolera usługi
sc.start() #uruchomienie usługi
file_path, w, h, frames_count = loop_data
self.__send_to_next_service(gif_data_output, file_path, w, h,
frames_count)
self.__push_notification()
def __send_to_next_service(self, out_stream, file_path, w, h,
frames_count):
msg_obj = {'path': file_path, 'w': w, 'h': h, 'frames': frames_count}
msg = json.dumps(msg_obj)
out_stream.send(msg)
def __push_notification(self):
'''push notification: "hey, I've just written loop video !" '''
try:
import socket
to_send = [1]
new_params = {"filtersOn": to_send}
host, port = 'localhost', 11112
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host, port))
s.sendall(json.dumps(new_params) + '\n')
s.close()
except Exception as e:
print 'push notification error: %s' % type(e)
if __name__ == "__main__":
config_name = os.path.join(os.path.dirname(__file__), "service.json")
sc = ServiceController(LoopDetectService, config_name)
sc.start()