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()