def host_client():
print "HOST CLIENT IS OBSOLETE"
sys.exit(1)
return SOCKET.CLIENT(
CONFIG.pdhosts_server_host, CONFIG.pdhosts_server_port,
(CONFIG.client_private_key_file, CONFIG.client_certificate_file,
CONFIG.ca_certificate_file))
def Unlock_Host(self, host):
if not self.hosts.has_key(host):
raise SOCKET.COMMAND_EXCEPTION("Invalid host")
if not self.hosts[host]["locked"]:
raise SOCKED.COMMAND_EXCEPTION("Host already unlocked")
self.hosts[host]["locked"] = 0
self.Write_Host_List()
def Deactivate_Session(self, session_id, state):
self.Validate_Session_Id(session_id)
if state == "active":
raise SOCKET.COMMAND_EXCEPTION("state must not be active")
if self.sessions[session_id]["state"] != "active":
raise SOCKET.COMMAND_EXCEPTION("session already inactive")
if self.sessions[session_id]["machine"] == None:
raise SOCKET.COMMAND_EXCEPTION(
"session is not bound to machine but session is inactive: PANIC"
)
self.hosts_client.Release_Host(self.sessions[session_id]["machine"],
self.sessions[session_id]["claim_id"])
self.sessions[session_id]["claim_id"] = None
self.sessions[session_id]["machine"] = None
self.sessions[session_id]["state"] = state
self.Write_Session(session_id)
def Activate_Session(self, session_id, desired_hostname):
self.Validate_Session_Id(session_id)
if self.sessions[session_id]["machine"] != None:
raise SOCKET.COMMAND_EXCEPTION(
"session is already bound to machine %s" %
self.sessions[session_id]["machine"])
if self.sessions[session_id]["state"] == "active":
raise SOCKET.COMMAND_EXCEPTION(
"session already activated but no machine: PANIC")
claim_id = self.hosts_client.Claim_Host(
desired_hostname, self.server_id,
self.sessions[session_id]["username"],
self.sessions[session_id]["cpus"],
self.sessions[session_id]["memory"])
self.sessions[session_id]["machine"] = desired_hostname
self.sessions[session_id]["claim_id"] = claim_id
self.sessions[session_id]["state"] = "active"
self.Write_Session(session_id)
def Register_Client(self, client_id, user, host):
if self.Registered(client_id):
raise SOCKET.COMMAND_EXCEPTION(
"Connection already registered for user %s" %
self.clientid_to_username[client_id])
if not self.users.has_key(user): self.users[user] = []
self.clientid_to_username[client_id] = user
self.users[user].append(client_id)
print "Registered user=%s client=%s" % (user, client_id)
def Send(self, client_id, users, data):
if not self.Registered(client_id):
raise SOCKET.COMMAND_EXCEPTION("Your client is not registered")
not_found_users = []
users_and_clientids = []
for user in users:
if not self.users.has_key(user) or len(self.users.keys()) == 0:
not_found_users.append(user)
else:
users_and_clientids.extend(
map(lambda x: (user, x), self.users[user]))
if len(not_found_users) > 0:
raise SOCKET.COMMAND_EXCEPTION("No registration for users: %s" %
",".join(not_found_users))
for user, clientid in users_and_clientids:
client = self.clients[clientid]
client.queueWrite(
(-100, None, ("SEND", (self.clientid_to_username[client_id],
client_id), users_and_clientids, data)))
def disk_client(volume):
print "DISK CLIENT IS CURRENTLY OFFLINE"
sys.exit(1)
volume_servers = {
"vol0": "solverh1",
"vol1": "solverh1",
"vol2": "solverh2",
"vol3": "solverh2"
}
return SOCKET.CLIENT(
volume_servers[volume], CONFIG.pddisk_server_port,
(CONFIG.client_private_key_file, CONFIG.client_certificate_file,
CONFIG.ca_certificate_file))
def __init__(self):
self.session_directory = CONFIG.session_directory
self.sessions = {}
self.next_id = 1
self.server_id = "pd/%s" % os.environ["HOSTNAME"]
self.hosts_client = client = SOCKET.CLIENT(
CONFIG.pdhosts_server_host, CONFIG.pdhosts_server_port,
(CONFIG.client_private_key_file, CONFIG.client_certificate_file,
CONFIG.ca_certificate_file))
print "our test %s" % self.hosts_client.Host_List()
self.Read_All_Sessions()
# Define RPC interface
self.mutex = threading.Lock()
self.commands = [
"Session_Info", "Session_List", "Create_Session",
"Activate_Session", "Deactivate_Session", "Label_Session",
"Update_State", "Host_List", "Update_Status",
"Remove_Status_If_Exists", "Session_Directory"
]
def Delete_Host(self, host):
if not self.hosts.has_key(host):
raise SOCKET.COMMAND_EXCEPTION("Invalid host")
del self.hosts[host]
self.Write_Host_List()
def Update_Status(self, client, session_id, key, value):
self.Validate_Session_Id(session_id)
self.sessions[session_id]["user_status"][key] = value
self.sessions[session_id]["last_update"] = time.time()
def Remove_Status_If_Exists(self, client, session_id, key):
self.Validate_Session_Id(session_id)
try:
del self.sessions[session_id]["user_status"][key]
except:
pass
def Backup(self):
while 1:
time.sleep(self.backup_interval)
print "Backing up..."
try:
self.mutex.acquire()
pickle.dump(self.sessions, open(self.session_file, "w"))
finally:
self.mutex.release()
import socket
if __name__ == "__main__":
server = SERVER()
SOCKET.SERVER(socket.gethostbyname(CONFIG.pdmon_server_host),
CONFIG.pdmon_server_port, server)
# SOCKET.SERVER(socket.gethostbyname(CONFIG.pdmon_server_host),CONFIG.pdmon_server_port,server,
# (CONFIG.server_private_key_file,CONFIG.server_certificate_file,CONFIG.ca_certificate_file))
from pd.common import CONFIG
from pd.common import SOCKET
import sys
import time
import os
import socket
import dialog
client = None
try:
client = SOCKET.CLIENT(
CONFIG.pdsim_server_host, CONFIG.pdsim_server_port,
(CONFIG.client_private_key_file, CONFIG.client_certificate_file,
CONFIG.ca_certificate_file))
# client=SOCKET.CLIENT(os.environ["PSIM_SERVER_HOST"],int(os.environ["PSIM_SERVER_PORT"]),
# (os.environ["PSIM_CLIENT_KEY"],os.environ["PSIM_CLIENT_CERT"],os.environ["PSIM_CA_CERT"]))
except KeyError:
print "You must define the environment variables PSIM_SERVER_HOST and PSIM_SERVER_PORT, PSIM_CLIENT_KEY, \nPSIM_CA_CERT, PSIM_CLIENT_CERT"
sys.exit(1)
except socket.error:
print "Unable to connect to server"
sys.exit(1)
username = os.environ["USER"]
def handle_dialog_code(d, code):
if code in (d.DIALOG_CANCEL, d.DIALOG_ESC):
sys.exit(1)
return 0
if not self.users.has_key(user) or len(self.users.keys()) == 0:
not_found_users.append(user)
else:
users_and_clientids.extend(
map(lambda x: (user, x), self.users[user]))
if len(not_found_users) > 0:
raise SOCKET.COMMAND_EXCEPTION("No registration for users: %s" %
",".join(not_found_users))
for user, clientid in users_and_clientids:
client = self.clients[clientid]
client.queueWrite(
(-100, None, ("SEND", (self.clientid_to_username[client_id],
client_id), users_and_clientids, data)))
def Send_Text(self, client_id, users, message):
return self.Send(client_id, users, ("MESSAGE", message))
def Send_Picture(self, client_id, users, picture):
return self.Send(client_id, users, ("PICTURE", picture))
def Users(self, client):
return self.users
if __name__ == "__main__":
server = SEND_SERVER()
SOCKET.SERVER(
socket.gethostbyname(CONFIG.pdsend_server_host),
CONFIG.pdsend_server_port, server
) #,(CONFIG.server_private_key_file,CONFIG.server_certificate_file,CONFIG.ca_certificate_file))
def mon_client(timeout=0):
return SOCKET.CLIENT(CONFIG.pdmon_server_host, CONFIG.pdmon_server_port,
None, timeout)
def Set_User(self, host, user):
if not self.hosts.has_key(host):
raise SOCKET.COMMAND_EXCEPTION("Invalid host")
self.hosts[host]["user"] = user
return "failed to remove symlink"
elif os.system(zfs_destroy) != 0:
return "failed to destroy zfs"
elif os.system(mountpoint_destroy) != 0:
return "failed to remove mount point"
return "done"
def Set_Quota(self, directory_name, quota):
verify = self.Verify_Path(directory_name)
if verify: return verify
quota_re = re.compile("^[0-9]+[MG]$")
if not quota_re.match(quota):
return "invalid quota string"
vfs = directory_name[len("/solver/"):]
cmd = "zfs set quota=%s %s" % (quota, vfs)
if os.system(cmd) != 0:
return "failed to set quota"
return "quota set"
if __name__ == "__main__":
server = DISK_SERVER()
hostname = os.popen("hostname").readline()[:-1]
SOCKET.SERVER(socket.gethostbyname(hostname), CONFIG.pddisk_server_port,
server,
(CONFIG.server_private_key_file,
CONFIG.server_certificate_file, CONFIG.ca_certificate_file))
pass
def Validate_Session_Id(self, session_id):
if type(session_id) != int:
raise SOCKET.COMMAND_EXCEPTION("Invalid session id")
elif not self.sessions.has_key(session_id):
raise SOCKET.COMMAND_EXCEPTION("Invalid session id %d" %
session_id)
def Add_Host(self, host):
if self.hosts.has_key(host):
raise SOCKET.COMMAND_EXCEPTION("Host already added")
self.hosts[host] = {"user": None}
self.Write_Host_List()
