public static PathInfo Parse(string name, string s) { String[] parts = s.Split('|'); try { string type = parts[0]; int versionNumber = Int32.Parse(parts[1]); int sz = parts.Length - 2; IServiceAddress rootLeader = null; IServiceAddress[] servers = new IServiceAddress[sz]; for (int i = 0; i < sz; ++i) { bool isLeader = false; String item = parts[i + 2]; if (item.StartsWith("*")) { item = item.Substring(1); isLeader = true; } IServiceAddress addr = ServiceAddresses.ParseString(item); servers[i] = addr; if (isLeader) { rootLeader = addr; } } // Return the PathInfo object, return new PathInfo(name, type, versionNumber, rootLeader, servers); } catch (IOException e) { throw new ApplicationException(e.Message, e); } }
public override CommandResultCode Execute(IExecutionContext context, CommandArguments args) { NetworkContext networkContext = context as NetworkContext; if (networkContext == null) { return(CommandResultCode.ExecutionFailed); } if (!args.MoveNext()) { return(CommandResultCode.SyntaxError); } string role = args.Current; IServiceAddress address = null; if (args.MoveNext()) { if (args.Current != "on") { return(CommandResultCode.SyntaxError); } if (!args.MoveNext()) { return(CommandResultCode.SyntaxError); } try { address = ServiceAddresses.ParseString(args.Current); } catch (Exception) { Error.WriteLine("Invalid service address"); return(CommandResultCode.ExecutionFailed); } } else { IServiceAddress[] addresses = networkContext.Network.Configuration.NetworkNodes; if (addresses != null && addresses.Length == 1) { address = addresses[0]; } } if (address == null) { Error.WriteLine("cannot determine the address of the service to stop."); return(CommandResultCode.ExecutionFailed); } return(StopRole(networkContext, role, address)); }
public IServiceAddress Get(string path) { string rootServerStr = dictionary.GetValue(path); if (rootServerStr == null) { return(null); } try { return(ServiceAddresses.ParseString(rootServerStr)); } catch (Exception e) { throw new FormatException("Unable to parse service address: " + e.Message); } }
private static IServiceAddress[] ParseAddress(string value) { List <IServiceAddress> addresses = new List <IServiceAddress>(); string[] sp = value.Split(','); for (int i = 0; i < sp.Length; i++) { string s = sp[i].Trim(); if (s.Length > 0) { addresses.Add(ServiceAddresses.ParseString(s)); } } return(addresses.ToArray()); }
public void AddNetworkNode(string address) { if (String.IsNullOrEmpty(address)) { throw new ArgumentNullException("address"); } IServiceAddress serviceAddress = ServiceAddresses.ParseString(address); if (serviceAddress == null) { throw new ArgumentException("The address '" + address + "' is not supported."); } AddNetworkNode(serviceAddress); }
private IServiceAddress[] ParseMachineAddressList(string rootAddress) { String[] machines = rootAddress.Split(','); try { IServiceAddress[] services = new IServiceAddress[machines.Length]; for (int i = 0; i < machines.Length; ++i) { services[i] = ServiceAddresses.ParseString(machines[i].Trim()); } return(services); } catch (FormatException e) { Out.WriteLine("Error parsing machine address: " + e.Message); throw; } }
protected override void OnStart() { try { // Read the manager server address from the properties file, Properties p = new Properties(); // Contains the root properties, string propFile = Path.Combine(path, "00.properties"); if (File.Exists(propFile)) { FileStream fin = new FileStream(propFile, FileMode.Open, FileAccess.Read, FileShare.Read); p.Load(fin); fin.Close(); } // Fetch the manager server property, String v = p.GetProperty("manager_server_address"); if (v != null) { String[] addresses = v.Split(','); int sz = addresses.Length; ManagerServices = new IServiceAddress[sz]; for (int i = 0; i < sz; ++i) { ManagerServices[i] = ServiceAddresses.ParseString(addresses[i]); } } } catch (IOException e) { throw new ApplicationException("IO Error: " + e.Message); } // Adds all the files to the path info queue, string[] rootFiles = Directory.GetFiles(path); foreach (string f in rootFiles) { String fname = Path.GetFileName(f); if (!fname.Contains(".")) { pathInitializationQueue.Add(f); } } base.OnStart(); }
private CommandResultCode RemovePath(NetworkContext context, string pathName, string rootAddress) { IServiceAddress address; // If machine is null, we need to find the machine the path is on, if (rootAddress == null) { PathInfo pathInfo = context.Network.GetPathInfo(pathName); if (pathInfo == null) { Out.WriteLine("The path '" + pathName + "' was not found."); return(CommandResultCode.ExecutionFailed); } address = pathInfo.RootLeader; } else { address = ServiceAddresses.ParseString(rootAddress); } Out.WriteLine("Removing path " + pathName + " from root " + address); Out.Flush(); MachineProfile p = context.Network.GetMachineProfile(address); if (p == null) { Out.WriteLine("Error: Machine was not found in the network schema."); return(CommandResultCode.ExecutionFailed); } if (!p.IsRoot) { Out.WriteLine("Error: Given machine is not a root."); return(CommandResultCode.ExecutionFailed); } // Remove the path, context.Network.RemovePathFromNetwork(pathName, address); Out.WriteLine("done."); return(CommandResultCode.Success); }
public void AddNetworkNode(IServiceAddress address) { lock (stateLock) { IServiceAddress[] nodes; string value = GetString(NetworkNodeList, null); if (value != null) { nodes = ParseAddress(value); int index = Array.BinarySearch(nodes, address); if (index >= 0) { throw new ArgumentException("The address '" + address + "' is already present."); } IServiceAddress[] oldNodes = nodes; nodes = new IServiceAddress[oldNodes.Length + 1]; Array.Copy(oldNodes, 0, nodes, 0, oldNodes.Length); nodes[nodes.Length - 1] = address; } else { nodes = new IServiceAddress[] { address }; } StringBuilder sb = new StringBuilder(); for (int i = 0; i < nodes.Length; i++) { IServiceAddressHandler handler = ServiceAddresses.GetHandler(nodes[i]); sb.Append(handler.ToString(nodes[i])); if (i < nodes.Length - 1) { sb.Append(", "); } } SetValue(NetworkNodeList, sb.ToString()); } }
protected override void OnStart() { localDb = new FileSystemDatabase(dbpath); localDb.Start(); SetBlockDatabase(localDb); // Read the unique id value, string f = Path.Combine(basePath, ManagerProperties); if (File.Exists(f)) { StreamReader reader = new StreamReader(f); string line; while ((line = reader.ReadLine()) != null) { if (line.StartsWith("id=")) { int uniqueId = Int32.Parse(line.Substring(3)); UniqueManagerId = uniqueId; } } reader.Close(); } // Read all the registered block servers that were last persisted and // populate the manager with them, f = Path.Combine(basePath, RegisteredBlockServers); if (File.Exists(f)) { StreamReader reader = new StreamReader(f); string line; while ((line = reader.ReadLine()) != null) { int p = line.IndexOf(","); long guid = Int64.Parse(line.Substring(0, p)); IServiceAddress addr = ServiceAddresses.ParseString(line.Substring(p + 1)); AddRegisteredBlockService(guid, addr); } reader.Close(); } // Read all the registered root servers that were last persisted and // populate the manager with them, f = Path.Combine(basePath, RegisteredRootServers); if (File.Exists(f)) { StreamReader reader = new StreamReader(f); string line; while ((line = reader.ReadLine()) != null) { IServiceAddress addr = ServiceAddresses.ParseString(line); AddRegisteredRootService(addr); } reader.Close(); } // Read all the registered manager servers that were last persisted and // populate the manager with them, f = Path.Combine(basePath, RegisteredManagerServers); if (File.Exists(f)) { StreamReader reader = new StreamReader(f); string line; while ((line = reader.ReadLine()) != null) { IServiceAddress addr = ServiceAddresses.ParseString(line); AddRegisteredManagerService(addr); } reader.Close(); } // Perform the initialization procedure (contacts the other managers and // syncs data). base.OnStart(); }
public void Process(object state) { Socket socket = (Socket)state; Stream socket_in = new NetworkStream(socket, FileAccess.Read); Stream socket_out = new NetworkStream(socket, FileAccess.Write); try { // 30 minute timeout on proxy connections, socket.SendTimeout = 30 * 60 * 1000; // Wrap the input stream in a data and buffered input stream, BufferedStream bin = new BufferedStream(socket_in, 1024); BinaryReader din = new BinaryReader(bin); // Wrap the output stream in a data and buffered output stream, BufferedStream bout = new BufferedStream(socket_out, 1024); BinaryWriter dout = new BinaryWriter(bout); // Perform the handshake, DateTime systemtime = DateTime.Now; dout.Write(systemtime.ToUniversalTime().ToBinary()); dout.Flush(); long back = din.ReadInt64(); if (systemtime.ToUniversalTime().ToBinary() != back) { throw new IOException("Bad protocol request"); } dout.Write("CloudB Proxy Service"); dout.Flush(); string net_password = din.ReadString(); // The connector to proxy commands via, TcpServiceConnector connector = new TcpServiceConnector(net_password); // The rest of the communication will be command requests; while (true) { // Read the command, char command = din.ReadChar(); if (command == '0') { // Close connection if we receive a '0' command char dout.Close(); din.Close(); return; } int addressCode = din.ReadInt32(); Type addressType = ServiceAddresses.GetAddressType(addressCode); if (addressType == null || addressType != typeof(TcpServiceAddress)) { throw new ApplicationException("Invalid address type."); } int addressLength = din.ReadInt32(); byte[] addressBytes = new byte[addressLength]; din.Read(addressBytes, 0, addressLength); IServiceAddressHandler handler = ServiceAddresses.GetHandler(addressType); TcpServiceAddress address = (TcpServiceAddress)handler.FromBytes(addressBytes); IEnumerable <Message> request = service.MessageSerializer.Deserialize(din.BaseStream); Message response; // Proxy the command over the network, if (command == 'a') { response = connector.Connect(address, ServiceType.Admin).Process(request); } else if (command == 'b') { response = connector.Connect(address, ServiceType.Block).Process(request); } else if (command == 'm') { response = connector.Connect(address, ServiceType.Manager).Process(request); } else if (command == 'r') { response = connector.Connect(address, ServiceType.Root).Process(request); } else { throw new IOException("Unknown command to proxy: " + command); } // Return the result, service.MessageSerializer.Serialize(response, dout.BaseStream); dout.Flush(); } } catch (SocketException e) { if (e.ErrorCode == (int)SocketError.ConnectionReset) { // Ignore connection reset messages, } } catch (IOException e) { if (e is EndOfStreamException) { // Ignore this one oo, } else { service.Logger.Error("IO Error during connection input", e); } } finally { // Make sure the socket is closed before we return from the thread, try { socket.Close(); } catch (IOException e) { service.Logger.Error("IO Error on connection close", e); } } }
public override CommandResultCode Execute(IExecutionContext context, CommandArguments args) { if (Application.ActiveContext != null && Application.ActiveContext.IsIsolated) { Error.WriteLine("a context is already opened: try to disconnect first"); Error.WriteLine(); return(CommandResultCode.ExecutionFailed); } if (!args.MoveNext()) { return(CommandResultCode.SyntaxError); } if (args.Current != "to") { return(CommandResultCode.SyntaxError); } if (!args.MoveNext()) { return(CommandResultCode.SyntaxError); } string address = args.Current; IServiceAddress serviceAddress; try { serviceAddress = ServiceAddresses.ParseString(address); } catch (Exception) { Error.WriteLine("Invalid service address specified: {0}", address); return(CommandResultCode.ExecutionFailed); } NetworkConfigSource configSource = new NetworkConfigSource(); try { configSource.AddNetworkNode(serviceAddress); } catch (Exception e) { Error.WriteLine("The address '" + address + "' is invalid: " + e.Message); return(CommandResultCode.ExecutionFailed); } string protocol = "tcp"; string credentials = String.Empty; string format = "binary"; if (args.MoveNext()) { if (args.Current == "identified") { if (!args.MoveNext()) { return(CommandResultCode.SyntaxError); } if (args.Current != "by") { return(CommandResultCode.SyntaxError); } if (!args.MoveNext()) { return(CommandResultCode.SyntaxError); } credentials = args.Current; if (args.MoveNext()) { if (args.Current != "on") { return(CommandResultCode.SyntaxError); } protocol = args.Current; if (args.MoveNext()) { if (args.Current != "with") { return(CommandResultCode.SyntaxError); } format = args.Current; } } } else if (args.Current == "on") { if (!args.MoveNext()) { return(CommandResultCode.SyntaxError); } protocol = args.Current; if (args.MoveNext()) { if (args.Current != "with") { return(CommandResultCode.SyntaxError); } format = args.Current; } } else if (args.Current == "with") { if (!args.MoveNext()) { return(CommandResultCode.SyntaxError); } format = args.Current; } else { return(CommandResultCode.SyntaxError); } } IServiceConnector connector; if (protocol == "tcp") { if (String.IsNullOrEmpty(credentials)) { while (String.IsNullOrEmpty(credentials = Readline.ReadPassword("password: "******"please provide a valid password..."); } Out.WriteLine(); } connector = new TcpServiceConnector(credentials); } else if (protocol == "http") { string userName = credentials; string password = null; int index = credentials.IndexOf(':'); if (index != -1) { password = credentials.Substring(index + 1); userName = credentials.Substring(0, index); } if (String.IsNullOrEmpty(password)) { while (String.IsNullOrEmpty(password = Readline.ReadPassword("password: "******"please provide a valid password..."); } Out.WriteLine(); } // TODO: connector = new HttpServiceConnector(userName, password); Out.WriteLine("Not supported yet."); return(CommandResultCode.ExecutionFailed); } else { return(CommandResultCode.SyntaxError); } IMessageSerializer serializer; if (format == "binary") { serializer = new BinaryRpcMessageSerializer(); } else if (format == "xml") { //TODO: serializer = new XmlRpcMessageSerializer(); return(CommandResultCode.ExecutionFailed); } else if (format == "json") { if (JsonRpcMessageSerializer == null) { Error.WriteLine("JSON serializer was not installed."); Error.WriteLine(); return(CommandResultCode.ExecutionFailed); } serializer = JsonRpcMessageSerializer; } else { return(CommandResultCode.SyntaxError); } connector.MessageSerializer = serializer; NetworkProfile networkProfile = new NetworkProfile(connector); networkProfile.Configuration = configSource; //TODO: test the connection is correct ... ((CloudAdmin)Application).SetNetworkContext(new NetworkContext(networkProfile)); Out.WriteLine("connected successfully to {0}", address); Out.WriteLine(); return(CommandResultCode.Success); }