def GetJobDetail(jobId):
job = None
dataHandler = DataHandler()
jobs = dataHandler.GetJob(jobId=jobId)
if len(jobs) == 1:
job = jobs[0]
job["log"] = ""
#jobParams = json.loads(base64.b64decode(job["jobMeta"]))
#jobPath,workPath,dataPath = GetStoragePath(jobParams["jobPath"],jobParams["workPath"],jobParams["dataPath"])
#localJobPath = os.path.join(config["storage-mount-path"],jobPath)
#logPath = os.path.join(localJobPath,"joblog.txt")
#print logPath
#if os.path.isfile(logPath):
# with open(logPath, 'r') as f:
# log = f.read()
# job["log"] = log
# f.close()
if "jobDescription" in job:
job.pop("jobDescription",None)
try:
log = dataHandler.GetJobTextField(jobId,"jobLog")
try:
if isBase64(log):
log = base64.b64decode(log)
except Exception:
pass
if log is not None:
job["log"] = log
except:
job["log"] = "fail-to-get-logs"
dataHandler.Close()
return job
def tune_lr_using_10_fold():
dh = DataHandler('data/train-set-feature-engineered.csv', 'prediction_label')
headers, train_features, train_prediction_labels = dh.get_numeric_data_set()
#train_features = dh.get_k_best_features(len(train_features[0]), train_features, train_prediction_labels)
data_sets = dh.get_cross_validation_data_sets(10, train_features, train_prediction_labels)
accuracy = []
for data_set_number in data_sets:
data_set = data_sets.get(data_set_number)
training_set = data_set[0]
tuning_set = data_set[1]
train_features = training_set["data_points"]
train_prediction_labels = training_set["labels"]
# Feature selection
train_features, selected_features = dh.get_k_best_features(len(train_features[0]), train_features, train_prediction_labels)
test_features = tuning_set["data_points"]
test_prediction_labels = tuning_set["labels"]
# Feature selection
test_features = dh.get_new_feature_vec(test_features, selected_features)
lr = LogisticRegression(train_features, train_prediction_labels, test_features, test_prediction_labels, 0.3)
eval_metrics = EvaluationMetrics(lr, test_features, test_prediction_labels)
eval = eval_metrics.evaluate()
accuracy.append(eval['accuracy'])
average_accuracy = sum(accuracy) / len(accuracy)
print average_accuracy
def Run():
while True:
try:
config["racks"] = k8sUtils.get_node_labels("rack")
config["skus"] = k8sUtils.get_node_labels("sku")
except Exception as e:
print e
try:
dataHandler = DataHandler()
pendingJobs = dataHandler.GetPendingJobs()
printlog("updating status for %d jobs" % len(pendingJobs))
for job in pendingJobs:
try:
print "Processing job: %s, status: %s" % (job["jobId"],
job["jobStatus"])
if job["jobStatus"] == "queued":
SubmitJob(job)
elif job["jobStatus"] == "killing":
KillJob(job)
elif job["jobStatus"] == "scheduling" or job[
"jobStatus"] == "running":
UpdateJobStatus(job)
elif job["jobStatus"] == "unapproved":
AutoApproveJob(job)
except Exception as e:
print e
except Exception as e:
print e
time.sleep(1)
def KillJob(job, desiredState="killed"):
dataHandler = DataHandler()
result, detail = k8sUtils.GetJobStatus(job["jobId"])
dataHandler.UpdateJobTextField(job["jobId"], "jobStatusDetail",
base64.b64encode(json.dumps(detail)))
logging.info("Killing job %s, with status %s, %s" %
(job["jobId"], result, detail))
if "jobDescriptionPath" in job and job["jobDescriptionPath"] is not None:
jobDescriptionPath = os.path.join(config["storage-mount-path"],
job["jobDescriptionPath"])
if os.path.isfile(jobDescriptionPath):
if k8sUtils.kubectl_delete(jobDescriptionPath) == 0:
dataHandler.UpdateJobTextField(job["jobId"], "jobStatus",
desiredState)
return True
else:
dataHandler.UpdateJobTextField(
job["jobId"], "errorMsg",
"Cannot delete job from Kubernetes Cluster!")
else:
dataHandler.UpdateJobTextField(job["jobId"], "errorMsg",
"Cannot find job description file!")
dataHandler.UpdateJobTextField(job["jobId"], "jobStatus", "error")
return False
def ApproveJob(job):
logging.info("start to Approve job...")
dataHandler = DataHandler()
dataHandler.ApproveJob(job["jobId"])
dataHandler.Close()
return True
def RunCommand(command):
dataHandler = DataHandler()
k8sUtils.kubectl_exec("exec %s %s" %
(command["jobId"], command["command"]))
dataHandler.FinishCommand(command["id"])
dataHandler.Close()
return True
def GetJobLog(userName, jobId):
dataHandler = DataHandler()
jobs = dataHandler.GetJob(jobId=jobId)
if len(jobs) == 1:
if jobs[0]["userName"] == userName or AuthorizationManager.HasAccess(
userName, ResourceType.VC, jobs[0]["vcName"],
Permission.Collaborator):
try:
log = dataHandler.GetJobTextField(jobId, "jobLog")
try:
if isBase64(log):
log = base64.b64decode(log)
except Exception:
pass
if log is not None:
return {
"log": log,
"cursor": None,
}
except:
pass
return {
"log": {},
"cursor": None,
}
def GetJobList(userName, vcName, jobOwner, num=None):
try:
dataHandler = DataHandler()
jobs = []
hasAccessOnAllJobs = False
if AuthorizationManager.HasAccess(userName, ResourceType.VC, vcName,
Permission.Collaborator):
hasAccessOnAllJobs = True
if jobOwner != "all" or not hasAccessOnAllJobs:
jobs = jobs + GetUserPendingJobs(userName, vcName)
jobs = jobs + dataHandler.GetJobList(
userName, vcName, num,
"running,queued,scheduling,unapproved,pausing,paused",
("<>", "and"))
else:
jobs = GetUserPendingJobs(jobOwner, vcName)
for job in jobs:
job.pop('jobMeta', None)
dataHandler.Close()
return jobs
except Exception as e:
logger.error('Exception: %s', str(e))
logger.warn("Fail to get job list for user %s, return empty list",
userName)
return []
def __init__(self, type='Chrome', db_ip=DATABASE_IP, db_user=DATABASE_ACCOUNT, db_pwd=DATABASE_PWD,
db_name=DATABASE_NAME, open_browser=False):
self.browser_type = type
self.db_ip = db_ip
self.db_user = db_user
self.db_pwd = db_pwd
self.db_name = db_name
self.db = None
self.connected = False
self.browsers = []
user = getpass.getuser()
if type == 'Chrome':
if sys.platform == 'darwin' and user == 'sunhua':
self.exe_path = '/Users/sunhua/desktop/chromedriver'
elif sys.platform == 'win32':
self.exe_path = 'win32/chromedriver.exe'
elif sys.platform == 'darwin':
self.exe_path = 'mac/chromedriver'
elif type == 'Firefox':
if sys.platform == 'darwin' and user == 'sunhua':
self.exe_path = '/Users/sunhua/desktop/geckodriver'
elif sys.platform == 'win32':
self.exe_path = 'win32/geckodriver.exe'
elif sys.platform == 'darwin':
self.exe_path = 'mac/geckodriver'
self.dat = DataHandler()
if open_browser:
self.open_browser()
def GetJobStatus(jobId):
result = None
dataHandler = DataHandler()
result = dataHandler.GetJobTextFields(jobId,
["jobStatus", "jobTime", "errorMsg"])
dataHandler.Close()
return result
def GetResourceAcl(resource):
try:
with acl_cache_lock:
return acl_cache[resourceKeyPrefix + resource]
except KeyError:
pass
dataHandler = DataHandler()
ret = []
try:
ret = dataHandler.GetResourceAcl(resource)
identities = {}
for ace in ret:
identityKey = identityKeyPrefix + ace["identityName"]
if identityKey not in identities:
identities[identityKey] = []
identities[identityKey].append(ace)
with acl_cache_lock:
acl_cache[resourceKeyPrefix + resource] = ret
acl_cache.update(identities)
except Exception as e:
logger.error("Get resoure acl error for resource: %s, ex: %s",
resource, str(e))
finally:
dataHandler.Close()
return ret
def UpdateAce(identityName, resource, permissions, isDeny):
dataHandler = DataHandler()
ret = False
try:
identityId = 0
if identityName.isdigit():
identityId = int(identityName)
else:
identityId = IdentityManager.GetIdentityInfoFromDB(
identityName)["uid"]
if identityId == INVALID_ID:
info = IdentityManager.GetIdentityInfoFromAD(identityName)
IdentityManager.UpdateIdentityInfo(identityName,
info["uid"],
info["gid"],
info["groups"])
identityId = info["uid"]
ret = dataHandler.UpdateAce(identityName, identityId, resource,
permissions, isDeny)
with acl_cache_lock:
acl_cache.pop(resourceKeyPrefix + resource, None)
acl_cache.pop(identityKeyPrefix + identityName, None)
except Exception as e:
logger.warn("Fail to Update Ace for user %s, ex: %s", identityName,
str(e))
finally:
dataHandler.Close()
return ret
def ListStorages(userName, vcName):
ret = []
dataHandler = DataHandler()
if AuthorizationManager.HasAccess(userName, ResourceType.VC, vcName, Permission.User):
ret = dataHandler.ListStorages(vcName)
dataHandler.Close()
return ret
def main():
LOG = setupLogger()
LOG.info('STARTING')
# wait until we should start. Make this into a class or method?
# while now()>endCheckTime() or now()<startCheckTime():
# LOG.info('Pinging every 120 seconds to check if the person should be asleep.')
# stallAction(120)
key_getter = TokenGetter(os.path.join(getPath(), 'tokens.txt'))
api_handler = APIHandler(FitbitURL, OutFile, key_getter)
data_handler = DataHandler()
#Make the API call
APIResponse = api_handler.cancelIfAPICallBad()
sleep_checker = SleepChecker(OutFile)
LOG.info('Polling until the user is asleep.')
while sleep_checker.isAwake():
stallAction(600) #Check every 10 minutes if the user is asleep.
APIResponse = api_handler.cancelIfAPICallBad()
sleeping, start_time = data_handler.getSleepStartTime(APIResponse)
#The user is now asleep.
user = '******' # Temporary username being used.
LOG.info('User ' + user + ' started sleeping at ' + str(start_time) +
' today.')
wake_up = WakeUpCaller()
wake_up.callWake(start_time)
def set_user_directory():
dataHandler = DataHandler()
users = dataHandler.GetUsers()
for username, userid in users:
if "@" in username:
username = username.split("@")[0]
if "/" in username:
username = username.split("/")[1]
if "\\" in username:
username = username.split("\\")[1]
userpath = os.path.join(config["storage-mount-path"],
"work/" + username)
if not os.path.exists(userpath):
logging.info("Found a new user %s" % username)
logging.info("Creating home directory %s for user %s" %
(userpath, username))
os.system("mkdir -p " + userpath)
os.system("chown -R " + userid + ":" + "500000513 " + userpath)
sshkeypath = os.path.join(userpath, ".ssh/id_rsa")
if not os.path.exists(sshkeypath):
logging.info("Creating sshkey for user %s" % (username))
os.system("mkdir -p " + os.path.dirname(sshkeypath))
os.system("ssh-keygen -t rsa -b 4096 -f %s -P ''" % sshkeypath)
os.system("chown -R " + userid + ":" + "500000513 " + userpath)
os.system("chmod 700 -R " + os.path.dirname(sshkeypath))
def _input_fn(mode=None, params=None):
"""Loads the dataset, decodes, reshapes and preprocesses it for use. Computations performed on CPU."""
with tf.device('/cpu:0'):
if mode == 'train':
dataset = DataHandler(mode, "train",
params).prepare_for_train()
elif mode == 'eval':
dataset = DataHandler(mode, "validation",
params).prepare_for_eval(
params.eval_batch_size)
elif mode == 'test':
dataset = DataHandler(mode, "test", params).prepare_for_eval(
params.eval_batch_size)
else:
raise ValueError('_input_fn received invalid MODE')
return dataset.make_one_shot_iterator().get_next()
def update_job_logs():
while True:
try:
dataHandler = DataHandler()
pendingJobs = dataHandler.GetPendingJobs()
for job in pendingJobs:
try:
if job["jobStatus"] == "running":
logging.info("updating job logs for job %s" %
job["jobId"])
jobParams = json.loads(
base64.b64decode(job["jobParams"]))
jobPath, workPath, dataPath = GetStoragePath(
jobParams["jobPath"], jobParams["workPath"],
jobParams["dataPath"])
localJobPath = os.path.join(
config["storage-mount-path"], jobPath)
logPath = os.path.join(localJobPath, "logs/joblog.txt")
extract_job_log(job["jobId"], logPath,
jobParams["userId"])
except Exception as e:
logging.error(e)
except Exception as e:
logging.error(e)
time.sleep(1)
def getWakeTime(self):
user = self.getUser()
FitbitURL = "https://api.fitbit.com/1/user/" + user + "/sleep/date/" + today_as_dt + ".json"
LOG = setupLogger()
LOG.info('STARTING')
key_getter_location = os.path.join(getPath(), 'Tokens.txt')
print key_getter_location
key_getter = TokenGetter(key_getter_location)
api_handler = APIHandler(FitbitURL, OutFile, key_getter)
data_handler = DataHandler()
#Make the API call
APIResponse = api_handler.cancelIfAPICallBad()
sleep_checker = SleepChecker(OutFile)
LOG.info("Checking if the user is asleep.")
if sleep_checker.isAwake():
LOG.info("User is still awake.")
return '06:00:00'
else:
APIResponse = api_handler.cancelIfAPICallBad()
sleeping, start_time = data_handler.getSleepStartTime(APIResponse)
#Sleeping is true now.
LOG.info('You started sleeping at ' + str(start_time) + ' today.')
wake_up = WakeUpCaller()
return wake_up.calculateWakeTime(start_time)
def _HasAccess(identity_name, resource_acl_path, permissions):
start_time = time.time()
requested_access = "%s;%s;%s" % (str(identity_name), resource_acl_path,
str(permissions))
value = resource_acl_cache.get(requested_access)
if value is not None:
logger.info('[cached] Yes for %s in time %s' %
(requested_access, time.time() - start_time))
return value
data_handler = None
try:
data_handler = DataHandler()
identities = []
try:
identities = get_identity_info_from_db(data_handler,
identity_name)["groups"]
identities = map(lambda x: int(x), identities)
except Exception as e:
logger.warn("Failed to get identities list: %s" % e)
identities = []
#TODO: handle isDeny
while resource_acl_path:
acl = data_handler.GetResourceAcl(resource_acl_path)
for ace in acl:
ace_id = int(ace["identityId"])
id_in_identities = ace_id in identities
id_in_range = ace_id < INVALID_RANGE_START or ace_id > INVALID_RANGE_END
if ace["identityName"] == identity_name or (
id_in_identities and id_in_range):
permissions = permissions & (~ace["permissions"])
if not permissions:
logger.info(
'Yes for %s in time %s' %
(requested_access, time.time() - start_time))
resource_acl_cache.add(requested_access, True)
return True
resource_acl_path = AuthorizationManager.__GetParentPath(
resource_acl_path)
logger.info("No for %s in time %s" %
(requested_access, time.time() - start_time))
resource_acl_cache.add(requested_access, False)
return False
except Exception as e:
logger.error("Exception: %s" % e)
logger.warn("No (exception) for %s in time %s" %
(requested_access, time.time() - start_time))
return False
finally:
if data_handler is not None:
data_handler.Close()
def ApproveJob(jobId): dataHandler = DataHandler() ret = False jobs = dataHandler.GetJob(jobId=jobId) if len(jobs) == 1: ret = dataHandler.ApproveJob(jobId) dataHandler.Close() return ret
def AddCommand(jobId,command): dataHandler = DataHandler() ret = False jobs = dataHandler.GetJob(jobId=jobId) if len(jobs) == 1: ret = dataHandler.AddCommand(jobId,command) dataHandler.Close() return ret
def GetCommands(userName, jobId):
commands = []
dataHandler = DataHandler()
jobs = dataHandler.GetJob(jobId=jobId)
if jobs[0]["userName"] == userName or AuthorizationManager.HasAccess(userName, ResourceType.VC, jobs[0]["vcName"], Permission.Collaborator):
commands = dataHandler.GetCommands(jobId=jobId)
dataHandler.Close()
return commands
def __init__(self):
"""
The consturctor that read the movie-to-name dataset.
"""
tempdataset = DataHandler()
self.dataset = tempdataset
self.readMovieName()
def UpdateVC(userName, vcName, quota, metadata):
ret = None
dataHandler = DataHandler()
if AuthorizationManager.IsClusterAdmin(userName):
ret = dataHandler.UpdateVC(vcName, quota, metadata)
else:
ret = "Access Denied!"
dataHandler.Close()
return ret
def DeleteVC(userName, vcName):
ret = None
dataHandler = DataHandler()
if AuthorizationManager.IsClusterAdmin(userName):
ret = dataHandler.DeleteVC(vcName)
else:
ret = "Access Denied!"
dataHandler.Close()
return ret
def UpdateStorage(userName, vcName, url, storageType, metadata, defaultMountPath):
ret = None
dataHandler = DataHandler()
if AuthorizationManager.HasAccess(userName, ResourceType.VC, vcName, Permission.Admin):
ret = dataHandler.UpdateStorage(vcName, url, storageType, metadata, defaultMountPath)
else:
ret = "Access Denied!"
dataHandler.Close()
return ret
def DeleteStorage(userName, vcName, url):
ret = None
dataHandler = DataHandler()
if AuthorizationManager.HasAccess(userName, ResourceType.VC, vcName, Permission.Admin):
ret = dataHandler.DeleteStorage(vcName, url)
else:
ret = "Access Denied!"
dataHandler.Close()
return ret
def AddStorage(userName, vcName, url, storageType, metadata, defaultMountPath):
ret = None
dataHandler = DataHandler()
if AuthorizationManager.IsClusterAdmin(userName):
ret = dataHandler.AddStorage(vcName, url, storageType, metadata, defaultMountPath)
else:
ret = "Access Denied!"
dataHandler.Close()
return ret
def GetJobStatus(jobId):
result = None
dataHandler = DataHandler()
jobs = dataHandler.GetJob(jobId=jobId)
if len(jobs) == 1:
key_list = ["jobStatus", "jobTime", "errorMsg"]
result = {key: jobs[0][key] for key in key_list}
dataHandler.Close()
return result
def PauseJob(userName, jobId):
dataHandler = DataHandler()
ret = False
jobs = dataHandler.GetJob(jobId=jobId)
if len(jobs) == 1:
if jobs[0]["userName"] == userName or AuthorizationManager.HasAccess(userName, ResourceType.VC, jobs[0]["vcName"], Permission.Admin):
ret = dataHandler.UpdateJobTextField(jobId,"jobStatus","pausing")
dataHandler.Close()
return ret
