class FlowerPi(object):
def __init__(self):
self.hardware = Hardware()
a = Astral()
a.solar_depression = 'civil'
self.city = a['Kiev']
self.rpc_server = RPCServer(self.hardware)
self.rpc_server.start()
def process(self):
now = datetime.now()
print("Processing... Current time: {}".format(str(now)))
sun = self.city.sun(date=now, local=True)
sunrise = sun['sunrise']
sunset = sun['sunset']
if sunrise.hour == now.hour and sunrise.minute == now.minute:
print("Sunrise. Time: {}".format(str(now)))
self.hardware.turn_lamp_low()
if sunset.hour == now.hour and sunset.minute == now.minute:
print("Sunset. Time: {}".format(str(now)))
self.hardware.turn_lamp_off()
def helpFuncs():
from pprint import pprint
rpcServer = RPCServer.getInstance()
methods = listFuncs()
for mName in listFuncs():
rpcServer.getBatchServer().system.methodHelp(mName)
methodsHelp = zip(methods, rpcServer.getBatchServer()())
RPCServer.getInstance().resetBatch()
pprint(dict(methodsHelp))
def runBatch(reset = True):
res = RPCServer.getInstance().getBatchServer()()
if reset:
RPCServer.getInstance().resetBatch()
endBatch()
resultsList = []
for r in res:
if isinstance(r, str):
tpe = r.split("-",1)[0]
resInstance = eval( "%s(id='%s')" % (tpe, r) )
resultsList.append(resInstance)
else:
resultsList.append(r)
return resultsList
def __init__(self):
self.hardware = Hardware()
a = Astral()
a.solar_depression = 'civil'
self.city = a['Kiev']
self.rpc_server = RPCServer(self.hardware)
self.rpc_server.start()
def fork_process(self, index, processor_cls):
if index == self.__server_count:
return
forkPID = os.fork()
if forkPID == 0:
server = RPCServer(self.__zk_address,
self.__zk_path,
self.__zk_version,
self.__handler,
self.__address,
self.__port[index],
self.__weight,
self.__zk_timeout)
server.start(processor_cls)
else:
index += 1
self.__processores.append(forkPID)
self.fork_process(index, processor_cls)
class HAInstance(object):
server = RPCServer.get_rpc_server()
instance_list = None
ha_instance_list = None
host = subprocess.check_output(['hostname']).strip()
@staticmethod
def init():
HAInstance.instance_list = []
HAInstance.ha_instance_list = {}
@staticmethod
def get_instance_from_controller():
# host_instance = {}
try:
cluster_list = HAInstance.server.listCluster()
for cluster in cluster_list:
cluster_uuid = cluster[0]
HAInstance.ha_instance_list[cluster_uuid] = HAInstance._get_ha_instance(cluster_uuid)
host_instance = HAInstance._get_instance_by_node(HAInstance.ha_instance_list)
for cluster_id, instance_list in host_instance.iteritems():
for instance in instance_list:
HAInstance.add_instance(cluster_id, instance)
except Exception as e:
message = "HAInstance get_instance_from_controller Except:" + str(e)
logging.error(message)
print(message)
@staticmethod
def _get_ha_instance(cluster_id):
instance_list = []
try:
instance_list = HAInstance.server.listInstance(cluster_id, False)["data"]["instance_list"]
except Exception as e:
message = "_get_ha_instance--get instance list from controller(rpc server) fail" + str(e)
# instance_list = []
logging.error(message)
finally:
return instance_list
@staticmethod
def _get_instance_by_node(instance_lists):
for id, instance_list in instance_lists.iteritems():
for instance in instance_list[:]:
if HAInstance.host not in instance[2]:
# print instance[2]
instance_list.remove(instance)
return instance_lists
@staticmethod
def add_instance(cluster_id, instance):
"""
:param cluster_id:
:param instance:
"""
print("add vm")
vm = Instance(cluster_id = cluster_id, ha_instance = instance)
HAInstance.instance_list.append(vm)
@staticmethod
def get_instance_list():
return HAInstance.instance_list
@staticmethod
def get_instance(name):
"""
:param name:
:return:
"""
for instance in HAInstance.instance_list:
if instance.name == name:
return instance
return None
@staticmethod
def update_ha_instance():
HAInstance.init()
HAInstance.get_instance_from_controller()
print("update HA Instance finish")
def __init__(self):
self.nova_client = NovaClient.get_instance()
self.server = RPCServer.get_rpc_server()
self.vm_name = None
self.failed_info = None
self.recovery_type = ""
def initializeClient(configFileName = 'config.cfg'):
global global_config
global clientId
global createCount
global gcThreshold
createCount = 0
global_config = Configuration(configFileName)
rpcServer = RPCServer.getInstance( global_config.RPCServerURL )
clientId = rpcServer.getServer()._requestClientId()
gcThreshold = global_config.GCThreshold
global filteredMethods
filteredMethods = filter(lambda mName: mName[:7] != 'system.' and mName[0] != '_',
rpcServer.getInteractiveServer().system.listMethods())
proxyFuncsSrc = """def %(methodName)s(*args):
\"\"\"%(methodHelp)s\"\"\"
global createCount
global gcThreshold
mName = '%(methodName)s'
newArgs = [clientId]
rpcServer = RPCServer.getInstance()
for arg in args:
if type(arg) in ( type(()), type([]) ):
newArgs.append( __elemsToStr(arg) )
elif isinstance(arg, Variable):
newArgs.append(arg.getId())
else:
newArgs.append(arg)
try:
result = rpcServer.getServer().%(methodName)s(*newArgs)
except:
raise
#result's first chars before the "-" indicate the type of the result
#UNLESS the result is an string repr of the number, in which case
#it is not processed
if isinstance(result, str):
tpe = result.split("-",1)[0]
if tpe.isalpha():
strToEval = "%%s(id='%%s')" %% (tpe, result)
result = eval(strToEval)
if mName.endswith("Create"):
createCount += 1
if createCount > gcThreshold:
runGC(result.getId())
createCount = 0
return result
"""
for mName in filteredMethods:
rpcServer.getBatchServer().system.methodHelp(mName)
methodsHelp = zip(filteredMethods, rpcServer.getBatchServer()())
for methodAndHelpPair in methodsHelp:
exec proxyFuncsSrc % \
{'methodName': methodAndHelpPair[0],
'methodHelp': methodAndHelpPair[1]
} in globals()
return globals()
def endBatch(): RPCServer.getInstance().setBatch(False)
def runBatch(reset = True):
res = RPCServer.getInstance().getBatchServer()()
if reset:
RPCServer.getInstance().resetBatch()
return [x for x in res]
def beginBatch(): RPCServer.getInstance().setBatch(True)
