class Controller(threading.Thread):
def __init__(self, config):
threading.Thread.__init__(self)
logger.debug('Initializing Controller RPC thread.')
self.lock = threading.Lock()
self.safeMode = True
self.credential = None
self.config = config
self.hostname = socket.gethostname()
server_secured_url = 'https://' + config.get(
'server', 'hostname') + ':' + config.get('server',
'secured_url_port')
self.registerUrl = server_secured_url + '/agent/register/' + self.hostname
self.heartbeatUrl = server_secured_url + '/agent/heartbeat/' + self.hostname
self.netutil = NetUtil()
def start(self):
self.actionQueue = ActionQueue(self.config)
self.actionQueue.start()
self.register = Register()
self.heartbeat = Heartbeat(self.actionQueue)
pass
def __del__(self):
logger.info("Server connection disconnected.")
pass
def registerWithServer(self):
retry = False
firstTime = True
registered = False
id = -1
ret = {}
while registered == False:
try:
data = json.dumps(self.register.build(id))
logger.info("Registering with the server " +
pprint.pformat(data))
req = urllib2.Request(self.registerUrl, data,
{'Content-Type': 'application/json'})
stream = security.secured_url_open(req)
response = stream.read()
stream.close()
ret = json.loads(response)
logger.info("Registered with the server with " +
pprint.pformat(ret))
registered = True
pass
except Exception, err:
delay = self.netutil.CONNECT_SERVER_RETRY_INTERVAL_SEC
logger.info("Unable to connect to: " + self.registerUrl,
exc_info=True)
""" Sleeping for {0} seconds and then retrying again """.format(
delay)
time.sleep(delay)
pass
pass
return ret
def test_ActionQueueStartStop(self, CustomServiceOrchestrator_mock,
get_mock, process_command_mock):
CustomServiceOrchestrator_mock.return_value = None
dummy_controller = MagicMock()
config = MagicMock()
actionQueue = ActionQueue(config, dummy_controller)
actionQueue.start()
time.sleep(3)
actionQueue.stop()
actionQueue.join()
self.assertEqual(actionQueue.stopped(), True, 'Action queue is not stopped.')
self.assertTrue(process_command_mock.call_count > 1)
def test_ActionQueueStartStop(self, CustomServiceOrchestrator_mock,
get_mock, process_command_mock):
CustomServiceOrchestrator_mock.return_value = None
dummy_controller = MagicMock()
config = MagicMock()
actionQueue = ActionQueue(config, dummy_controller, self.agentToggleLogger)
actionQueue.start()
time.sleep(3)
actionQueue.stop()
actionQueue.join()
self.assertEqual(actionQueue.stopped(), True, 'Action queue is not stopped.')
self.assertTrue(process_command_mock.call_count > 1)
class Controller(threading.Thread):
def __init__(self, config, range=30):
threading.Thread.__init__(self)
logger.debug('Initializing Controller RPC thread.')
self.lock = threading.Lock()
self.safeMode = True
self.credential = None
self.config = config
self.hostname = hostname.hostname()
server_secured_url = 'https://' + config.get(
'server', 'hostname') + ':' + config.get('server',
'secured_url_port')
self.registerUrl = server_secured_url + '/agent/v1/register/' + self.hostname
self.unregisterUrl = server_secured_url + '/agent/v1/unregister/' + self.hostname
self.heartbeatUrl = server_secured_url + '/agent/v1/heartbeat/' + self.hostname
self.netutil = NetUtil()
self.responseId = -1
self.repeatRegistration = False
self.cachedconnect = None
self.range = range
self.hasMappedComponents = True
self.actionQueue = ActionQueue(self.config)
self.actionQueue.start()
self.register = Register(self.config)
self.unregister = Unregister(self.config)
self.heartbeat = Heartbeat(self.actionQueue, self.config)
def __del__(self):
logger.info("Server connection disconnected.")
pass
def unregisterWithServer(self):
id = -1
ret = self.retriedRequest(self.unregisterUrl,
lambda: self.unregister.build(id))
if ret["response"] == "OK":
logger.info("Unregistered with the server")
print("Unregistered with the server")
else:
logMsg = "Error while unregistering with server: %s" % ret[
"errorMessage"]
logger.info(logMsg)
print(logMsg)
return ret
def registerWithServer(self):
id = -1
ret = self.retriedRequest(self.registerUrl,
lambda: self.register.build(id))
logger.info("Registered with the server")
print("Registered with the server")
return ret
def retriedRequest(self, requestUrl, payloadBuilder):
successfulRequest = False
id = -1
ret = {}
while not successfulRequest:
try:
data = json.dumps(payloadBuilder())
logger.info("Sending request to url " + requestUrl + " " +
pprint.pformat(data))
response = self.sendRequest(requestUrl, data)
ret = json.loads(response)
logger.info("Request successful " + pprint.pformat(ret))
self.responseId = int(ret['responseId'])
successfulRequest = True
if 'statusCommands' in ret.keys():
logger.info("Got status commands on registration " +
pprint.pformat(ret['statusCommands']))
self.addToQueue(ret['statusCommands'])
pass
else:
self.hasMappedComponents = False
pass
except ssl.SSLError:
self.repeatRegistration = False
return
except Exception, err:
# try a reconnect only after a certain amount of random time
delay = randint(0, self.range)
logger.info("Unable to connect to: " + requestUrl,
exc_info=True)
""" Sleeping for {0} seconds and then retrying again """.format(
delay)
time.sleep(delay)
pass
pass
return ret
class Controller(threading.Thread):
def __init__(self, config):
threading.Thread.__init__(self)
logger.debug('Initializing Controller RPC thread.')
self.lock = threading.Lock()
self.safeMode = True
self.credential = None
self.config = config
#Disabled security until we have fix for AMBARI-157
#if(config.get('controller', 'user')!=None and config.get('controller', 'password')!=None):
# self.credential = { 'user' : config.get('controller', 'user'),
# 'password' : config.get('controller', 'password')
# }
self.url = config.get('controller', 'url') + '/agent/controller/heartbeat/' + socket.gethostname()
def start(self):
self.actionQueue = ActionQueue(self.config)
self.actionQueue.start()
self.heartbeat = Heartbeat(self.actionQueue)
def __del__(self):
logger.info("Controller connection disconnected.")
def run(self):
id='-1'
if self.credential!=None:
auth_handler = urllib2.HTTPBasicAuthHandler()
auth_handler.add_password(realm="Controller",
uri=self.url,
user=self.credential['user'],
passwd=self.credential['password'])
opener = urllib2.build_opener(auth_handler)
urllib2.install_opener(opener)
retry=False
firstTime=True
while True:
try:
if retry==False:
data = json.dumps(self.heartbeat.build(id))
logger.debug(data)
req = urllib2.Request(self.url, data, {'Content-Type': 'application/json'})
f = urllib2.urlopen(req)
response = f.read()
f.close()
data = json.loads(response)
id=int(data['responseId'])
self.actionQueue.put(data)
if retry==True or firstTime==True:
logger.info("Controller connection established")
firstTime=False
retry=False
except Exception, err:
retry=True
if "code" in err:
logger.error(err.code)
else:
logger.error("Unable to connect to: "+self.url,exc_info=True)
if self.actionQueue.isIdle():
time.sleep(30)
else:
time.sleep(1)
class Controller(threading.Thread):
def __init__(self, config, range=30):
threading.Thread.__init__(self)
logger.debug('Initializing Controller RPC thread.')
self.lock = threading.Lock()
self.safeMode = True
self.credential = None
self.config = config
self.hostname = hostname.hostname()
server_secured_url = 'https://' + config.get('server', 'hostname') + ':' + config.get('server', 'secured_url_port')
self.registerUrl = server_secured_url + '/agent/v1/register/' + self.hostname
self.unregisterUrl = server_secured_url + '/agent/v1/unregister/' + self.hostname
self.heartbeatUrl = server_secured_url + '/agent/v1/heartbeat/' + self.hostname
self.netutil = NetUtil()
self.responseId = -1
self.repeatRegistration = False
self.cachedconnect = None
self.range = range
self.hasMappedComponents = True
self.actionQueue = ActionQueue(self.config)
self.actionQueue.start()
self.register = Register(self.config)
self.unregister = Unregister(self.config)
self.heartbeat = Heartbeat(self.actionQueue, self.config)
def __del__(self):
logger.info("Server connection disconnected.")
pass
def unregisterWithServer(self):
id = -1
ret = self.retriedRequest(self.unregisterUrl, lambda: self.unregister.build(id))
if ret["response"] == "OK":
logger.info("Unregistered with the server")
print("Unregistered with the server")
else:
logMsg = "Error while unregistering with server: %s" % ret["errorMessage"]
logger.info(logMsg)
print(logMsg)
return ret
def registerWithServer(self):
id = -1
ret = self.retriedRequest(self.registerUrl, lambda: self.register.build(id))
logger.info("Registered with the server")
print("Registered with the server")
return ret
def retriedRequest(self, requestUrl, payloadBuilder):
successfulRequest=False
id = -1
ret = {}
while not successfulRequest:
try:
data = json.dumps(payloadBuilder())
logger.info("Sending request to url " + requestUrl + " " + pprint.pformat(data))
response = self.sendRequest(requestUrl, data)
ret = json.loads(response)
logger.info("Request successful " + pprint.pformat(ret))
self.responseId= int(ret['responseId'])
successfulRequest = True
if 'statusCommands' in ret.keys():
logger.info("Got status commands on registration " + pprint.pformat(ret['statusCommands']) )
self.addToQueue(ret['statusCommands'])
pass
else:
self.hasMappedComponents = False
pass
except ssl.SSLError:
self.repeatRegistration=False
return
except Exception, err:
# try a reconnect only after a certain amount of random time
delay = randint(0, self.range)
logger.info("Unable to connect to: " + requestUrl, exc_info = True)
""" Sleeping for {0} seconds and then retrying again """.format(delay)
time.sleep(delay)
pass
pass
return ret
