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
