protected void SendRpcMessage(string address, string method,
string query, bool secure)
{
Address addr = AddressParser.Parse(address);
SendRpcMessage(addr, method, query, secure);
}
/** Greedy routing. gen_arg is the Address of the destination
*/
public override void GenerateTree(Channel q, MapReduceArgs mr_args)
{
object gen_arg = mr_args.GenArg;
Log("{0}: {1}, greedy generator called, arg: {2}.",
this.TaskName, _node.Address, gen_arg);
string address = gen_arg as string;
AHAddress a = (AHAddress)AddressParser.Parse(address);
ArrayList retval = new ArrayList();
ConnectionTable tab = _node.ConnectionTable;
ConnectionList structs = tab.GetConnections(ConnectionType.Structured);
Connection next_closest = structs.GetNearestTo((AHAddress)_node.Address, a);
if (next_closest != null)
{
//arguments do not change at all
MapReduceInfo mr_info = new MapReduceInfo(next_closest.Edge, mr_args);
retval.Add(mr_info);
}
Log("{0}: {1}, greedy generator returning: {2} senders.",
this.TaskName, _node.Address, retval.Count);
//Send the result:
q.Enqueue(retval.ToArray(typeof(MapReduceInfo)));
}
public void GetByCode()
{
var source = new AddressParser(Log, FolderWithLucene);
var list = new string[]
{
"500000360000039",
"010000010000095",
"010000010000000",
"470130009190000",
"220610000010033",
};
long total = 0;
int count = 0;
for (int i = 0; i < 10; i++)
{
foreach (var code in list)
{
count++;
var b = DateTime.UtcNow.Ticks;
var d = source.GetByCode(code);
System.Diagnostics.Trace.WriteLine(code + ": " + d.ToString());
total += (DateTime.UtcNow.Ticks - b);
}
}
System.Diagnostics.Trace.WriteLine(string.Format("Total: {0} ms", 1.0 * total / (TimeSpan.TicksPerMillisecond * count)));
}
public void ShortAddressIsParsed()
{
var parsed = new AddressParser().Parse("abba[mnop]qrst");
var manual = new Ip7Address(new [] { new Ip7Sequence("abba", false), new Ip7Sequence("mnop", true), new Ip7Sequence("qrst", false) });
Assert.Equal(manual, parsed);
}
public void AddressRegexIsLazy()
{
var addressParser = new AddressParser();
addressParser.StreetSuffixes.Add("EDGE", "EDGE");
Approvals.Verify(addressParser.AddressRegex);
}
public void AddressWithLeadingAndTrailingHypernetSequenceIsParsed()
{
var parsed = new AddressParser().Parse("[xxyy]abba[mnop]");
var manual = new Ip7Address(new [] { new Ip7Sequence("xxyy", true), new Ip7Sequence("abba", false), new Ip7Sequence("mnop", true) });
Assert.Equal(manual, parsed);
}
// With pre-defined dependancy
public MonitorTabViewModel(LatencyMonitorConfig configuration)
{
this.Model = new MonitorTabModel();
this.Configuration = configuration;
MonitorObserver = new Observer <MonitorServiceNotify>(
(data) => { NotifyObservers(data); });
this.startLatencyMonitorCommand = new StartLatencyMonitorCommand(this.Model.Addresses, this);
this.AddNewAddressCommand = new RelayCommand((obj) => {
AddNewAddress(txtb_newAddress);
});
this.AddNewAddressFromFileCommand = new RelayCommand((obj) =>
{
OpenFileDialog ofd = new OpenFileDialog();
bool?result = ofd.ShowDialog();
if (result == true)
{
AddMultipleNewAddresses(AddressParser.Parse(ofd.FileName));
}
});
Init();
}
static void Main(string[] args)
{
using (var reader = new StreamReader("bad.csv"))
using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
{
csv.Configuration.HasHeaderRecord = true;
csv.Configuration.Delimiter = ";";
csv.Configuration.MissingFieldFound = null;
csv.Configuration.BadDataFound = null; //?
csv.Configuration.HeaderValidated = null;
csv.Configuration.IgnoreQuotes = true;
using (var writer = new StreamWriter("../../../../result_digit21.csv"))
{
writer.NewLine = "\n";
while (csv.Read())
{
var input = csv.GetRecord <Data>();
var parser = new AddressParser();
input.addressNew = parser.Process(input.address);
writer.WriteLine(input.id + ";" + input.address + ";" + input.addressNew);
}
}
}
}
private void process_button_click(object sender, EventArgs e)
{
closed = false;
bool valid = new AddressParser(tbAddress.Text).parseAddress().IsCompleteAddress();
if (valid)
{
try
{
if (SearchResult == null || addressChanged)
{
SearchResult = new GetDeepSearch().search(tbAddress.Text, SettingForm.GetZWID());
addressChanged = false;
}
this.Hide();
}
catch (Exception ee)
{
MessageBox.Show(String.Format("Something went wrong : '{0}'", tbAddress.Text), ee.Message,
MessageBoxButtons.OK, MessageBoxIcon.Error);
SearchResult = null;
}
}
else
{
MessageBox.Show(String.Format("'{0}' is not a valid, please make sure you have city state and zip", tbAddress.Text), "Opps .. ",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
/// <summary>Called by HandleIPOut if the current packet has a Multicast
/// address in its destination field. This sends the multicast packet
/// to all members of the multicast group stored in the dht.</summary>
/// <param name="ipp">The IP Packet destined for multicast.</param>
/// <returns>This returns true since this is implemented.</returns>
protected override bool HandleMulticast(IPPacket ipp)
{
if (!_ipop_config.EnableMulticast)
{
return(true);
}
WaitCallback wcb = delegate(object o) {
Hashtable[] results = null;
try {
results = AppNode.Dht.Get(Encoding.UTF8.GetBytes(_ipop_config.IpopNamespace + ".multicast.ipop"));
} catch {
return;
}
foreach (Hashtable result in results)
{
try {
AHAddress target = (AHAddress)AddressParser.Parse(Encoding.UTF8.GetString((byte[])result["value"]));
if (IpopLog.PacketLog.Enabled)
{
ProtocolLog.Write(IpopLog.PacketLog, String.Format(
"Brunet destination ID: {0}", target));
}
SendIP(target, ipp.Packet);
}
catch {}
}
};
ThreadPool.QueueUserWorkItem(wcb, ipp);
return(true);
}
public static NodeInfo CreateInstance(IDictionary d)
{
Address address = null;
IList tas;
object addr_str = d["address"];
if (addr_str != null)
{
address = AddressParser.Parse((string)addr_str);
}
IList trans = d["transports"] as IList;
if (trans != null)
{
int count = trans.Count;
tas = new TransportAddress[count];
for (int i = 0; i < count; i++)
{
tas[i] = TransportAddressFactory.CreateInstance((string)trans[i]);
}
NodeInfo ni = CreateInstance(address, tas);
return(ni);
}
else
{
NodeInfo ni = CreateInstance(address);
return(ni);
}
}
public void CanBuildAddressFromXml()
{
// Address to compare against
var correctAddress = new Address
{
Id = 1,
Street = "667 Massachusetts Avenue",
City = "Cambridge",
State = "MA",
Zip = "02139"
};
// Generate an address from an XML string using the factory method
var address = AddressParser.ParseAddressFromXml
(
@"<Address>
<UniqueId>1</UniqueId>
<Street>667 Massachusetts Avenue</Street>
<City>Cambridge</City>
<State>MA</State>
<Zip>02139</Zip>
</Address>"
);
Assert.True(address.Equals(correctAddress));
}
public void CanBuildAddressFromJson()
{
var correctAddress = new Address
{
Id = 1,
Street = "667 Massachusetts Avenue",
City = "Cambridge",
State = "MA",
Zip = "02139"
};
// Generate an address from an XML string using the factory method
var address = AddressParser.ParseAddressFromJson
(
@"{
""UniqueId"": 1,
""Street"": ""667 Massachusetts Avenue"",
""City"": ""Cambridge"",
""State"": ""MA"",
""Zip"": ""02139""
}"
);
Assert.True(address.Equals(correctAddress));
}
/// <summary> Handles the result of a crawl query.</summary>
protected void CrawlHandler(object o, EventArgs ea)
{
Address addr = Node.Address;
Channel q = (Channel)o;
try {
RpcResult res = (RpcResult)q.Dequeue();
Hashtable ht = (Hashtable)res.Result;
Address left = AddressParser.Parse((String)ht["left"]);
Address next = AddressParser.Parse((String)ht["right"]);
Address current = AddressParser.Parse((String)ht["self"]);
if (left.Equals(_previous))
{
_consistency++;
}
else if (_previous == null)
{
_first_left = left;
}
if (current.Equals(_first_left) && Node.Address.Equals(next))
{
_consistency++;
}
_previous = current;
addr = next;
} catch {}
CrawlNext(addr);
}
protected void FriendPing(string address)
{
Address addr = AddressParser.Parse(address);
Channel q = new Channel();
q.CloseAfterEnqueue();
q.CloseEvent += delegate(object obj, EventArgs eargs) {
try {
RpcResult res = (RpcResult)q.Dequeue();
string result = (string)res.Result;
string[] parts = result.Split(DELIM);
string dht_key = parts[0];
string response = parts[1];
if (response == "online")
{
SocialUser friend = _friends[dht_key];
friend.Time = DateTime.Now.ToString();
}
ProtocolLog.Write(SocialLog.SVPNLog, "PING FRIEND REPLY: " +
result);
} catch (Exception e) {
ProtocolLog.Write(SocialLog.SVPNLog, e.Message);
ProtocolLog.Write(SocialLog.SVPNLog, "PING FRIEND FAILURE: " +
address);
}
};
ISender sender = new AHExactSender(_node, addr);
_rpc.Invoke(sender, q, "SocialVPN.FriendPing", _local_user.DhtKey);
}
public void ParseAddressLine()
{
var addressParser = new AddressParser();
var result = addressParser.ParseAddressLine("3360 County Road F", true);
Approvals.Verify(result);
}
/**
* Generates tree for bounded broadcast. Algorithm works as follows:
* The goal is to broadcast to all nodes in range (start, end).
* Given a range (a, b), determine all connections that belong to this range.
* Let the left connections be l_1, l_2, ..... l_n.
* Let the right connections be r_1, r_2, ... , r_n.
* To left connection l_i assign the range [b_{i-1}, b_i).
* To right connection r_i assign the range [r_i, r_{i-1}]
* To the connection ln assign range [l_{n-1}, end)
* To the connection rn assign range (start, r_{n-1}]
*/
public override void GenerateTree(Channel q, MapReduceArgs mr_args)
{
ArrayList gen_list = mr_args.GenArg as ArrayList;
string start_range = gen_list[0] as string;
AHAddress start_addr = (AHAddress)AddressParser.Parse(start_range);
AHAddress end_addr;
string end_range;
/// If users do not specify an end range, this method understands
/// that users intend to broadcasting the whole range.
/// Thus, the address of end range is set to (start_address - 2),
/// the farthest address from the start_addr.
if (gen_list.Count < 2)
{
BigInteger start_int = start_addr.ToBigInteger();
BigInteger end_int = start_int - 2;
end_addr = new AHAddress(end_int);
end_range = end_addr.ToString();
}
else
{
end_range = gen_list[1] as string;
end_addr = (AHAddress)AddressParser.Parse(end_range);
}
Log("generating child tree, range start: {0}, range end: {1}.", start_range, end_range);
//we are at the start node, here we go:
ConnectionTable tab = _node.ConnectionTable;
ConnectionList structs = tab.GetConnections(ConnectionType.Structured);
List <MapReduceInfo> retval = new List <MapReduceInfo>();
if (InRange(_this_addr, start_addr, end_addr))
{
if (structs.Count > 0)
{
//make connection list in the range.
//left connection list is a list of neighbors which are in the range (this node, end of range)
//right connection list is a list of neighbors which are in the range (start of range, this node)
Brunet.Collections.Pair <List <Connection>, List <Connection> > cons = GetConnectionInfo(_this_addr, start_addr, end_addr, structs);
List <Connection> left_cons = cons.First as List <Connection>;
List <Connection> right_cons = cons.Second as List <Connection>;
//PrintConnectionList(left_cons);
//PrintConnectionList(right_cons);
retval = GenerateTreeInRange(start_addr, end_addr, left_cons, true, mr_args);
List <MapReduceInfo> ret_right = GenerateTreeInRange(start_addr, end_addr, right_cons, false, mr_args);
retval.AddRange(ret_right);
}
else //this node is a leaf node.
//MapReduceInfo mr_info = null;
//retval.Add(mr_info);
//Console.WriteLine("no connection in the range: return null info");
{
}
}
else // _node is out of range. Just pass it to the closest to the middle of range.
{
retval = GenerateTreeOutRange(start_addr, end_addr, mr_args);
}
q.Enqueue(retval.ToArray());
}
public void simple3()
{
Address a = new AddressParser("18332 28th NE Redmond 98052 ").parseAddress();
Assert.AreEqual("Redmond", a.City);
Assert.AreEqual("18332 28th NE", a.AddressLine);
Assert.AreEqual(null, a.State);
}
public static string AddressR1C1(this ExcelReference range)
{
if (range.IsSingleCell())
{
return(AddressParser.ToAddressR1C1(range.RowFirst, range.ColumnLast));
}
return($"{AddressParser.ToAddressR1C1(range.RowFirst, range.ColumnFirst)}:{AddressParser.ToAddressR1C1(range.RowLast, range.ColumnLast)}");
}
/*
* Add a friend from socialvpn.
* @param friend the friend to be added.
*/
public void AddFriend(SocialUser friend)
{
Address addr = AddressParser.Parse(friend.Address);
friend.IP = _rarad.RegisterMapping(friend.Alias, addr);
_node.ManagedCO.AddAddress(addr);
friend.Access = SocialUser.AccessTypes.Allow.ToString();
}
public object[] forwardingproxy(string relay, int init_option, string dest, int ttl, int ahOptions, int maxResultsToWait, string method, params object[] args)
{
Address forwarder = AddressParser.Parse(relay);
Address target = AddressParser.Parse(dest);
ForwardingSender s = new ForwardingSender(_node, forwarder, (ushort)init_option, target, (short)ttl, (ushort)ahOptions);
return(this.Proxy(s, maxResultsToWait, method, args));
}
public void StreetLineTests()
{
var addressParser = new AddressParser();
var streetPattern = new Regex(addressParser.StreetPattern, addressParser.MatchOptions);
var streetPatternMatch = streetPattern.Match("COUNTY ROAD F");
Approvals.Verify(streetPatternMatch);
}
/*
* Removes a friend from socialvpn.
* @param friend the friend to be removed.
*/
public void RemoveFriend(SocialUser friend)
{
Address addr = AddressParser.Parse(friend.Address);
_node.ManagedCO.RemoveAddress(addr);
_rarad.UnregisterMapping(friend.Alias);
friend.Access = SocialUser.AccessTypes.Block.ToString();
}
public object[] proxy(string node, int ahOptions, int maxResultsToWait,
string method, params object[] args)
{
Address target = AddressParser.Parse(node);
AHSender s = new AHSender(_node, target, (ushort)ahOptions);
return(this.Proxy(s, maxResultsToWait, method, args));
}
/// <summary>
/// 获取 指向单元格的公式
/// </summary>
/// <param name="range"></param>
/// <param name="useFirstCell">使用单元格范围中第一个单元格</param>
/// <returns></returns>
public static string Formula(this ExcelReference range, bool useFirstCell = false)
{
if (useFirstCell || range.IsSingleCell())
{
return($"=${AddressParser.GetColumnName(range.ColumnFirst)}${range.RowFirst+1}");
}
return($"=${AddressParser.GetColumnName(range.ColumnFirst)}${range.RowFirst+1}:${AddressParser.GetColumnName(range.ColumnLast)}${range.RowLast+1}");
}
public string Solve(string[] input)
{
var parser = new AddressParser();
var ips = input.Select(line => parser.Parse(line));
var inspector = new AddressInspector();
return(ips.Count(ip => inspector.DetectSsl(ip)).ToString());
}
public void ReplaceTest()
{
var address = "Нерезиновск, ул. Большая ордынка, д. 5";
var exp = "Москва, ул. Большая ордынка, д. 5";
var parser = new AddressParser();
var normalized = parser.Parse(address);
Assert.AreEqual(exp, normalized.Raw);
}
public void FloorSuffixed()
{
Assert.AreEqual("1", AddressParser.Parse("2790 Yew St., floor 1,#408").Floor);
Assert.AreEqual("22", AddressParser.Parse("2790 Yew St., floor 22, #408").Floor);
Assert.AreEqual("105", AddressParser.Parse("2790 Yew St., floor 105 apt.408").Floor);
Assert.AreEqual("M", AddressParser.Parse("2790 Yew St., floor M ").Floor);
Assert.AreEqual("L2", AddressParser.Parse("2790 Yew St., floor L2").Floor);
Assert.AreEqual("", AddressParser.Parse("2790 Yew St., floor #5").Floor);
}
public void simple1()
{
Address a = new AddressParser("18332 28th NE Redmond WA 98052").parseAddress();
Assert.AreEqual(a.City, "Redmond");
Assert.AreEqual(a.Zip, "98052");
Assert.AreEqual(a.AddressLine, "18332 28th NE");
Assert.AreEqual(a.State, "WA");
}
public void medium2()
{
Address a = new AddressParser("18332 28th NE, Redmond 98052 WA").parseAddress();
Assert.AreEqual("Redmond", a.City);
Assert.AreEqual("98052", a.Zip);
Assert.AreEqual("18332 28th NE", a.AddressLine);
Assert.AreEqual("WA", a.State);
}
public void ExtractingFirstInteger()
{
Assert.AreEqual(0, AddressParser.ExtractBeginingOfStringAsInteger(null));
Assert.AreEqual(0, AddressParser.ExtractBeginingOfStringAsInteger(""));
Assert.AreEqual(1, AddressParser.ExtractBeginingOfStringAsInteger("1"));
Assert.AreEqual(123, AddressParser.ExtractBeginingOfStringAsInteger("123"));
Assert.AreEqual(123, AddressParser.ExtractBeginingOfStringAsInteger("123-1"));
Assert.AreEqual(123, AddressParser.ExtractBeginingOfStringAsInteger(" 123"));
}
public void GetByIndex()
{
var source = new AddressParser(Log, FolderWithLucene);
var list = new string[]
{
"658390",
"659063",
"397670",
};
long total = 0;
int count = 0;
for (int i = 0; i < 10; i++)
{
foreach (var index in list)
{
count++;
var b = DateTime.UtcNow.Ticks;
var collection = source.GetByIndex(index);
System.Diagnostics.Trace.WriteLine(index + "...");
int? totalHits = null;
foreach (var d in collection)
{
if (!totalHits.HasValue)
{
totalHits = d.LastInfo.TotalHits;
System.Diagnostics.Trace.WriteLine("TotalHits: " + totalHits);
if (totalHits > 20) break;
}
System.Diagnostics.Trace.WriteLine(index + ": " + d.ToString());
}
total += (DateTime.UtcNow.Ticks - b);
}
}
System.Diagnostics.Trace.WriteLine(string.Format("Total: {0} ms", 1.0 * total / (TimeSpan.TicksPerMillisecond * count)));
}
public static CompaniesUsersAddresses LoadFrom(ITableReader reader)
{
Company[] companies = null;
User[] users = null;
Address[] addresses = null;
foreach (ITable table in reader.GetTables())
{
switch (table.Name)
{
case "Companies":
companies = new CompanyParser().GetAll(table).ToArray();
break;
case "Users":
users = new UserParser().GetAll(table).ToArray();
break;
case "Addresses":
addresses = new AddressParser().GetAll(table).ToArray();
break;
}
}
return new CompaniesUsersAddresses(companies, users, addresses);
}
public void GetChildren()
{
var source = new AddressParser(Log, FolderWithLucene);
var list = new string[]
{
// 1
"090000000000000",
"890000000000000",
// 2
"110070000000000",
"140280000000000",
"660120000000000",
// 3
"020000030000000",
"240020080000000",
"540060040000000",
// 4
"500000360000000",
"470130009190000",
"010000010080000",
"590190000480000",
"710240002550000",
};
long total = 0;
int count = 0;
for (int i = 0; i < 10; i++)
{
foreach (var code in list)
{
count++;
var b = DateTime.UtcNow.Ticks;
int level = source.GetLevel(code).Value + 1;
var collection = source.GetChildren(code);
System.Diagnostics.Trace.WriteLine(code + "...");
int? totalHits = null;
foreach (var d in collection)
{
if (!totalHits.HasValue)
{
totalHits = d.LastInfo.TotalHits;
System.Diagnostics.Trace.WriteLine("TotalHits: " + totalHits);
}
if (totalHits < 20) System.Diagnostics.Trace.WriteLine(" " + d.ToString());
try
{
Assert.That(d.Level, Is.GreaterThanOrEqualTo(level));
}
catch (Exception)
{
System.Diagnostics.Trace.WriteLine("warn:" + d.ToString());
throw;
}
}
total += (DateTime.UtcNow.Ticks - b);
}
}
System.Diagnostics.Trace.WriteLine(string.Format("Total: {0} ms", 1.0 * total / (TimeSpan.TicksPerMillisecond * count)));
}
public void GetRegions()
{
var list = GetAllRegions();
var source = new AddressParser(Log, FolderWithLucene);
foreach (var part in source.GetByLevel("010000000000000"))
{
Assert.IsTrue(list.ContainsKey(part.Id));
var d = list[part.Id];
Assert.That(part.Id, Is.EqualTo(d.Code));
Assert.That(part.NameWithReduction, Is.EqualTo(d.Name));
}
}
public void Search()
{
var list = new string[]
{
"Адыгея, Майкоп, Краснодарская",
"Воронежская, Петропавловский, Петропавловка, Садовая",
"Московская, Балашиха, Русавкино-Романово, Энергетическая",
"Балашиха Фадеева",
"Фадеева Балашиха",
"Респ Адыгея",
"Адыгея"
};
var source = new AddressParser(Log, FolderWithLucene);
long total = 0;
int count = 0;
for (int i = 0; i < 10; i++)
{
foreach (var filter in list)
{
count++;
var b = DateTime.UtcNow.Ticks;
var collection = source.Search(filter);
System.Diagnostics.Trace.WriteLine(filter + "...");
int? totalHits = null;
foreach (var d in collection)
{
if (!totalHits.HasValue)
{
totalHits = d.LastInfo.TotalHits;
System.Diagnostics.Trace.WriteLine("TotalHits: " + totalHits);
if (totalHits > 100) break;
}
System.Diagnostics.Trace.WriteLine(" " + d.Id + ":" + d.FullName);
}
total += (DateTime.UtcNow.Ticks - b);
}
}
System.Diagnostics.Trace.WriteLine(string.Format("Total: {0} ms", 1.0 * total / (TimeSpan.TicksPerMillisecond * count)));
}
public void GetReduction()
{
var list = LoadReductionInternal();
var source = new AddressParser(Log, FolderWithLucene);
foreach (var level in list.Keys.ToArray())
{
foreach (var reduction in list[level].Keys.ToArray())
{
var d = source.GetReduction(new ParsedAddressPart() { Level = level, Reduction = reduction });
EqualTo(d, list[level][reduction]);
}
}
}
public void AddressRegexIsLazy()
{
var addressParser = new AddressParser();
addressParser.StreetSuffixes.Add("EDGE", "EDGE");
Approvals.Verify(addressParser.AddressRegex);
}
