def __init__(self, host, token, verbose=False): """ """ self.host = host self.token = token self.incidentEndpoint = "https://events.pagerduty.com/generic/2010-04-15/create_event.json" self.weburl = "https://%s" % self.host self.baseurl = "https://%s/api/v1" % self.host self.http = HTTPHandler() self.http.verbose = verbose self.http.headers['Content-type'] = 'application/json'
def run ( self ): while self.running: try: client_socket, client_addr = self.sock.accept() client_socket.setblocking(1) client_thread = HTTPHandler(client_socket, client_addr) client_thread.start() except socket.timeout: pass self.sock.shutdown(1) self.sock.close()
def __init__(self, name, interfaces): Node.__init__(self, name, interfaces) self.conn = None if len(interfaces) > 1: raise Exception("Host.__init__: too many interfaces") self.__intf = interfaces[0] self.__httphandler = HTTPHandler(self.__send)
def __init__(self,host,username,password,verbose=False): """ """ self.routers = { 'MessagingRouter': 'messaging', 'EventsRouter': 'evconsole', 'ProcessRouter': 'process', 'ServiceRouter': 'service', 'DeviceRouter': 'device', 'NetworkRouter': 'network', 'TemplateRouter': 'template', 'DetailNavRouter': 'detailnav', 'ReportRouter': 'report', 'MibRouter': 'mib', 'ZenPackRouter': 'zenpack' } self.host = host self.username = username self.password = password self.baseurl = "http://%s:8080" % self.host self.login = { "__ac_name": self.username, "__ac_password": self.password, "submitted": "true", "came_from": "%s/zport/dmd" % self.baseurl } self.http = HTTPHandler() self.http.verbose = verbose self.http.persist("%s/zport/acl_users/cookieAuthHelper/login" % self.baseurl ,self.login)
class Host(Node): def __init__(self, name, interfaces): Node.__init__(self, name, interfaces) self.conn = None if len(interfaces) > 1: raise Exception("Host.__init__: too many interfaces") self.__intf = interfaces[0] self.__httphandler = HTTPHandler(self.__send) def __send(self, packet): self.send_packet(self.__intf, packet) def connect(self, _): print "Rejecting connection to %s - may not control a Host node" % self.name return False def handle_packet(self, intf, packet): """Replies to echo requests, arp requests, also TCP handshake, and simple HTTP Server""" self.__httphandler.process_packet(intf.ip, intf.mac, packet)
def __init__(self, host, token,verbose=False): """ """ self.host = host self.token = token self.incidentEndpoint = "https://events.pagerduty.com/generic/2010-04-15/create_event.json" self.weburl = "https://%s" % self.host self.baseurl = "https://%s/api/v1" % self.host self.http = HTTPHandler() self.http.verbose = verbose self.http.headers['Content-type'] = 'application/json'
class Client: def __init__(self): self.__interface = None self.__mac = None self.__ip = None self.__mask = None self.__http = HTTPHandler(self.send) def send(self, what): print "send " + repr(what) self.__prot.send(VNSPacket(self.__interface, what)) def callback(self, prot, msg): self.__prot = prot if self.__interface is None: for m in msg: for i in range(0, len(m)): # print dict(zip(m[::2],m[1::2])) if m[i] == VNSInterface.HWINTERFACE: self.__interface = m[i + 1] print "interface: " + self.__interface i += 1 elif m[i] == VNSInterface.HWSPEED: i += 2 elif m[i] == VNSInterface.HWETHER: self.__mac = m[i + 1][0:6] print "MAC : " + VNS.MACToString(self.__mac) i += 1 elif m[i] == VNSInterface.HWETHIP: self.__ip = m[i + 1] print "ip : " + VNS.SubnetToString(self.__ip) i += 2 elif m[i] == VNSInterface.HWSUBNET: i += 2 elif m[i] == VNSInterface.HWMASK: self.__mask = m[i + 1] print "mask : " + VNS.SubnetToString(self.__mask) else: print msg self.__http.process_packet(self.__ip, self.__mac, msg.ethernet_frame)
class HTTPHandlerTest(unittest.TestCase): def setUp(self): self.http = HTTPHandler("UnittestCookie") def tearDown(self): pass def testSimpleRequest(self): resp = self.http.sendRequest("http://i/Python/Unittest%20Equipment/XHTML.html", False, True, False, False, self.http.__browserHeaders) self.checkXHTMLHash(resp['content']) def testGetContent(self): resp = self.http.getContent("http://i/Python/Unittest%20Equipment/XHTML.html") self.checkXHTMLHash(resp) def checkXHTMLHash(self, resp): import hashlib resp_hash = hashlib.md5(resp).hexdigest() self.failUnlessEqual(resp_hash, "a328fa0c14f6c8c01ddd6f1aa67dd192", msg="Fail processing simple request.")
class ZenossHandler(): """ """ def __init__(self,host,username,password,verbose=False): """ """ self.routers = { 'MessagingRouter': 'messaging', 'EventsRouter': 'evconsole', 'ProcessRouter': 'process', 'ServiceRouter': 'service', 'DeviceRouter': 'device', 'NetworkRouter': 'network', 'TemplateRouter': 'template', 'DetailNavRouter': 'detailnav', 'ReportRouter': 'report', 'MibRouter': 'mib', 'ZenPackRouter': 'zenpack' } self.host = host self.username = username self.password = password self.baseurl = "http://%s:8080" % self.host self.login = { "__ac_name": self.username, "__ac_password": self.password, "submitted": "true", "came_from": "%s/zport/dmd" % self.baseurl } self.http = HTTPHandler() self.http.verbose = verbose self.http.persist("%s/zport/acl_users/cookieAuthHelper/login" % self.baseurl ,self.login) def request(self,router,method,data=[]): """ Handle HTTP GET / POST operations against Zenoss API """ self.http.headers['Content-type'] = 'application/json; charset=utf-8' self.http.connect("%s/zport/dmd/%s_router" % (self.baseurl,self.routers[router])) data = { "action": router, "method": method, "data": data, "type": 'rpc', "tid" : self.http.counter } self.http.transact(data) return self.http.response def getEvents(self): """ retrieve current console events """ data = dict(start=0, limit=100, dir='DESC', sort='severity') data['params'] = dict(severity=[5,4,3,2,1,0]) return self.request('EventsRouter','query',[data])["result"] def manageEventStatus(self,evids=[],action="acknowledge"): """ manage event status action = [acknowledge|close] """ data = [{"evids": evids}] return self.request('EventsRouter',action,data) def addEventMessage(self,evid,message): """ manage event open/close/acknowledge status """ data = { 'evid': evid, 'message':message } return self.request('EventsRouter','write_log',[data]) def getEventDetails(self,evid): """ manage event open/close/acknowledge status """ data = { 'evid': evid, } return self.request('EventsRouter','detail',[data]) def addLocation(self,path,id,description=None,address=None): """ manage event open/close/acknowledge status """ data = { 'type': 'organizer', 'contextUid:': path, 'id': id, 'description': description, 'address': address, } print "data",data return self.request('DeviceRouter','addLocationNode',[data])
def setUp(self): self.http = HTTPHandler("UnittestCookie")
def create_http_handler(self): self.httpHandler = HTTPHandler(self.tenantURL, self.tenantId, self.deviceId, self.deviceType, self.externalId, self.credentials)
class C8Y_Device: httpHandler = None opsHandler = None meaThread = None # Thread to run periodic measurements gpsThread = None # Thread to run periodic gps events def __init__(self, tenantURL, tenantId, deviceName, deviceType, externalId, deviceConfig): self.tenantURL = tenantURL self.tenantId = tenantId self.deviceName = deviceName self.deviceType = deviceType self.deviceId = 0 self.externalId = externalId self.deviceConfig = deviceConfig self.bootstrapCredentials = ["devicebootstrap", "Fhdt1bb1f"] self.credentials = [] self.fileHandle = None self.create_http_handler() def create_http_handler(self): self.httpHandler = HTTPHandler(self.tenantURL, self.tenantId, self.deviceId, self.deviceType, self.externalId, self.credentials) def create_operations_handler(self): self.opsHandler = Device_Operations_Handler(self, self.tenantURL, self.tenantId, self.deviceId, self.credentials, 0, 60000) #return True def read_credentials(self): credentials = [] currentDirectory = os.getcwd() for file in os.listdir(currentDirectory): if fnmatch.fnmatch(file, 'device.properties'): with open('device.properties') as credentialsFile: # 'device.properties' file should exist in this directory and contain 2 separate lines: # username # password line = credentialsFile.readline() cnt = 1 while line: credentials.append(line.strip()) line = credentialsFile.readline() cnt += 1 credentialsFile.close() self.credentials = credentials #print(self.credentials[0]+ "\n" + self.credentials[1]) credentialsAvailable = False if len(self.credentials) != 0: credentialsAvailable = True self.httpHandler.credentials = credentials return credentialsAvailable def request_credentials(self, deviceName): credentials = [] while len(credentials) == 0: time.sleep(5) credentials = self.get_device_credentials(deviceName) if len(credentials) != 0: # Implement https://stackoverflow.com/questions/14636290/secure-credential-storage-in-python print("Recieved new device credentials") file = open('device.properties', 'w') file.write(credentials[0] + "\n") file.write(credentials[1]) file.close() self.httpHandler.credentials = credentials #update self.credentials = credentials #return credentials def get_device_credentials(self, deviceName): print("Requesting credentials for device: " + deviceName) body = {"id": deviceName} headers = { 'Content-type': 'application/json', 'Accept': 'application/json' } url = self.tenantURL + 'devicecontrol/deviceCredentials' response = self.httpHandler.http_request('POST', headers, url, 'get_device_credentials', body) resp = response.json() credentials = [] if response.status_code == 201: credentials.append(resp['username']) credentials.append(resp['password']) else: stringToLog = "Please register & accept " + self.deviceName + " at:\n" + self.tenantURL + "apps/devicemanagement/index.html#/deviceregistration" print(stringToLog) #self.credentials = credentials return credentials def get_ManagedObject_for_a_specific_externalId(self): body = "" headers = { 'Content-type': 'application/json', 'Accept': 'application/json' } url = self.tenantURL + 'identity/externalIds/' + self.deviceType + "/" + self.externalId response = self.httpHandler.http_request('GET', headers, url, 'get_external_Id', body) isDeviceRegistered = False if response.status_code == 200: resp = response.json() deviceId = resp['managedObject']['id'] isDeviceRegistered = True elif response.status_code == 401: print("Device no longer exists at " + self.tenantURL + ". Remove device.properties file in local directory") sys.exit() else: deviceId = 0 self.deviceId = deviceId self.httpHandler.deviceId = deviceId return isDeviceRegistered def create_device(self): headers = { 'Content-type': 'application/json', 'Accept': 'application/json' } url = self.tenantURL + "inventory/managedObjects" body = { "name": self.deviceName, "type": self.deviceType, "c8y_IsDevice": {}, "com_cumulocity_model_Agent": {}, "c8y_SupportedOperations": [ "c8y_Restart", "c8y_Configuration", "c8y_SoftwareList", "c8y_Firmware", "c8y_UploadConfigFile", "c8y_DownloadConfigFile", "c8y_SendConfiguration", "c8y_Command", "c8y_LogfileRequest" ], "c8y_Hardware": { "revision": "1.0", "model": "IBR 1700", "serialNumber": self.externalId }, "c8y_Configuration": { "config": self.deviceConfig }, "c8y_Mobile": { "imei": "8611450130921231", "cellId": "4904-A496", "iccid": "89490200000876635112" }, "c8y_Firmware": { "name": "Firmware", "version": "1.0.0" }, "c8y_Software": { "agent_Version": "agent_rev1.0" }, "c8y_SupportedLogs": ["Info Log"] } response = self.httpHandler.http_request('POST', headers, url, 'create_device', body) if response.status_code != 201: print('Could not create Device: ' + self.deviceName) return False resp = response.json() print('Created device with id: ' + resp['id']) deviceId = resp['id'] self.deviceId = deviceId self.httpHandler.deviceId = deviceId return True def create_externalId(self): headers = { 'Content-Type': 'application/vnd.com.nsn.cumulocity.externalId+json', 'Accept': 'application/vnd.com.nsn.cumulocity.externalId+json' } url = self.tenantURL + "identity/globalIds/" + str( self.deviceId) + "/externalIds" data = {"externalId": self.externalId, "type": self.deviceType} r = requests.post(url=url, data=json.dumps(data), headers=headers, auth=(self.tenantId + "/" + self.credentials[0], self.credentials[1])) if r.status_code != 201: print('Could not create externalId for device: ' + str(self.deviceId)) #print(r.status_code) return False else: resp = r.json() print('Created externalId: ' + resp['externalId']) return True
def __init__(self): self.__interface = None self.__mac = None self.__ip = None self.__mask = None self.__http = HTTPHandler(self.send)
class PagerDutyHandler(): """ """ def __init__(self, host, token, verbose=False): """ """ self.host = host self.token = token self.incidentEndpoint = "https://events.pagerduty.com/generic/2010-04-15/create_event.json" self.weburl = "https://%s" % self.host self.baseurl = "https://%s/api/v1" % self.host self.http = HTTPHandler() self.http.verbose = verbose self.http.headers['Content-type'] = 'application/json' def request(self, endpoint, data=None, token=True, method="GET"): # data should be list of dicts """ Handle HTTP GET / POST operations against PagerDuty API """ if data and method == "GETARG": endpoint += '?%s' % urllib.urlencode(data) if token == True: self.http.headers['Authorization'] = 'Token token=%s' % self.token self.http.connect(endpoint) if data: if method == "POST": self.http.post(data) if method == "PUT": self.http.put(data) if method == "GET": self.http.session.add_data(json.dumps(data)) self.http.submit() return self.http.response def manageIncident(self, data, action="trigger"): """ action = [trigger|acknowledge|resolve] Manage PagerDuty Incidents """ data["event_type"] = action output = self.request(self.incidentEndpoint, data, token=False, method="POST") return output def updateStatus(self, data): """ action = [trigger|acknowledge|resolved] Manage PagerDuty Incidents """ return self.request("%s/incidents" % self.baseurl, data, token=True, method="PUT") def getServiceList(self): """ """ return self.request("%s/services" % self.baseurl) def getServiceDetail(self, id): """ """ return self.request("%s/services/%s" % (self.baseurl, id)) def getServiceLog(self, id): """ """ return self.request("%s/services/%s/log" % (self.baseurl, id)) def getIncidentList(self): """ """ return self.request("%s/incidents" % self.baseurl) def getIncidentByKey(self, key): """ Retrieve incident by its incident key """ data = {"incident_key": key} return self.request("%s/incidents" % self.baseurl, data, token=True, method="GETARG") def getIncidentDetail(self, id): """ """ return self.request("%s/incidents/%s/log_entries" % (self.baseurl, id)) def getIncidentLog(self, id): """ """ return self.request("%s/incidents/%s/log" % (self.baseurl, id)) def getMaintenanceWindows(self): #data = {"type":"ongoing"} return self.request("%s/maintenance_windows" % self.baseurl) def findService(self, serviceKey): """ find service info for given key """ services = self.getServiceList() for s in services["services"]: if s["service_key"] == serviceKey: return s return None def getServiceStatus(self, data): return data["status"] def inMaintenance(self, data): """ """ if self.getServiceStatus(data) == 'maintenance': return True return False def isDisabled(self, data): """ """ if self.getServiceStatus(data) == 'disabled': return True return False def isActive(self, data): """ """ if self.getServiceStatus(data) == 'active': return True return False
def track(args): if len(args) == 0: print formatDefinitions(defaults, 80) return try: config, files = parseargs(args, defaults, 0, 0) except ValueError, e: print 'error: ' + str(e) print 'run with no arguments for parameter explanations' return r = RawServer(Event(), config['timeout_check_interval'], config['socket_timeout']) t = Tracker(config, r) r.bind(config['port'], config['bind'], True) r.listen_forever(HTTPHandler(t.get, config['min_time_between_log_flushes'])) t.save_dfile() print '# Shutting down: ' + isotime() def size_format(s): if (s < 1024): r = str(s) + 'B' elif (s < 1048576): r = str(int(s / 1024)) + 'KiB' elif (s < 1073741824l): r = str(int(s / 1048576)) + 'MiB' elif (s < 1099511627776l): r = str(int((s / 1073741824.0) * 100.0) / 100.0) + 'GiB' else: r = str(int((s / 1099511627776.0) * 100.0) / 100.0) + 'TiB'
currentThread().name = 'main' # When python is started in the background it ignores SIGINT instead of throwing a KeyboardInterrupt def signal_die(signum, frame): signals = dict((getattr(signal, name), name) for name in dir(signal) if name.startswith('SIG') and '_' not in name) raise SystemExit("Caught %s; exiting" % signals.get(signum, "signal %d" % signum)) signal.signal(signal.SIGINT, signal.default_int_handler) signal.signal(signal.SIGTERM, signal_die) server = HTTPServer(('', config.localBindPort), HTTPHandler) HTTPHandler.enableStaticHandler('static') HTTPHandler.enableVue('components', 'views') try: console('main', 'Listening for connections') server.serve_forever() except KeyboardInterrupt: sys.__stdout__.write("\n\n") console('main', 'Exiting at user request') except (Exception, SystemExit) as e: sys.__stdout__.write("\n\n") console('main', '%s', e) console('main', 'Closing server sockets') server.server_close() console('main', 'Done')
class PagerDutyHandler(): """ """ def __init__(self, host, token,verbose=False): """ """ self.host = host self.token = token self.incidentEndpoint = "https://events.pagerduty.com/generic/2010-04-15/create_event.json" self.weburl = "https://%s" % self.host self.baseurl = "https://%s/api/v1" % self.host self.http = HTTPHandler() self.http.verbose = verbose self.http.headers['Content-type'] = 'application/json' def request(self, endpoint, data=None, token=True, method="GET"): # data should be list of dicts """ Handle HTTP GET / POST operations against PagerDuty API """ if data and method=="GETARG": endpoint += '?%s' % urllib.urlencode(data) if token == True: self.http.headers['Authorization'] = 'Token token=%s' % self.token self.http.connect(endpoint) if data: if method == "POST": self.http.post(data) if method == "PUT": self.http.put(data) if method == "GET": self.http.session.add_data(json.dumps(data)) self.http.submit() return self.http.response def manageIncident(self,data,action="trigger"): """ action = [trigger|acknowledge|resolve] Manage PagerDuty Incidents """ data["event_type"] = action output = self.request(self.incidentEndpoint,data,token=False,method="POST") return output def updateStatus(self,data): """ action = [trigger|acknowledge|resolved] Manage PagerDuty Incidents """ return self.request("%s/incidents" % self.baseurl, data, token=True, method="PUT") def getServiceList(self): """ """ return self.request("%s/services" % self.baseurl) def getServiceDetail(self,id): """ """ return self.request("%s/services/%s" % (self.baseurl,id)) def getServiceLog(self,id): """ """ return self.request("%s/services/%s/log" % (self.baseurl,id)) def getIncidentList(self): """ """ return self.request("%s/incidents" % self.baseurl) def getIncidentByKey(self,key): """ Retrieve incident by its incident key """ data = {"incident_key":key} return self.request("%s/incidents" % self.baseurl,data,token=True,method="GETARG") def getIncidentDetail(self,id): """ """ return self.request("%s/incidents/%s/log_entries" % (self.baseurl,id)) def getIncidentLog(self,id): """ """ return self.request("%s/incidents/%s/log" % (self.baseurl,id)) def getMaintenanceWindows(self): #data = {"type":"ongoing"} return self.request("%s/maintenance_windows" % self.baseurl) def findService(self,serviceKey): """ find service info for given key """ services = self.getServiceList() for s in services["services"] : if s["service_key"] == serviceKey: return s return None def getServiceStatus(self,data): return data["status"] def inMaintenance(self, data): """ """ if self.getServiceStatus(data) == 'maintenance': return True return False def isDisabled(self, data): """ """ if self.getServiceStatus(data) == 'disabled': return True return False def isActive(self, data): """ """ if self.getServiceStatus(data) == 'active': return True return False