251 lines
9.4 KiB
Plaintext
251 lines
9.4 KiB
Plaintext
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Microsoft Research Singularity
|
|
//
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//
|
|
// File: SeattleTrafficProxy.sg
|
|
//
|
|
// Note: A simple proxy module for the Seattle Traffic web service
|
|
//
|
|
|
|
using System;
|
|
using System.Diagnostics;
|
|
using System.Text;
|
|
using System.Collections;
|
|
using Microsoft.SingSharp;
|
|
using Microsoft.Singularity;
|
|
using Microsoft.Singularity.Channels;
|
|
using Microsoft.Singularity.SeattleTrafficProxy.Contracts;
|
|
using Microsoft.Singularity.Directory;
|
|
using Microsoft.Singularity.Xml;
|
|
using System;
|
|
|
|
using Microsoft.Contracts;
|
|
using Microsoft.SingSharp.Reflection;
|
|
using Microsoft.Singularity.Applications;
|
|
using Microsoft.Singularity.Io;
|
|
using Microsoft.Singularity.Configuration;
|
|
[assembly: Transform(typeof(ApplicationResourceTransform))]
|
|
|
|
namespace Microsoft.Singularity.Applications
|
|
{
|
|
[ConsoleCategory(HelpMessage="Mappoint proxy service", DefaultAction=true)]
|
|
internal class Parameters
|
|
{
|
|
[InputEndpoint("data")]
|
|
public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;
|
|
|
|
[OutputEndpoint("data")]
|
|
public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;
|
|
|
|
[Endpoint]
|
|
public readonly TRef<DirectoryServiceContract.Imp:Start> nsRef;
|
|
|
|
reflective internal Parameters();
|
|
|
|
internal int AppMain() {
|
|
return SeattleTrafficProxy.AppMain(this);
|
|
}
|
|
}
|
|
|
|
public class SeattleTrafficProxy
|
|
{
|
|
internal static int AppMain(Parameters! config)
|
|
{
|
|
|
|
DirectoryServiceContract.Imp ds = (config.nsRef).Acquire();
|
|
if (ds == null) {
|
|
throw new Exception("Unable to acquire handle to the Directory Service root");
|
|
}
|
|
ds.RecvSuccess();
|
|
|
|
|
|
// Here is the channel we use to communicate with
|
|
// the NameServer
|
|
ServiceProviderContract.Imp! nsImp;
|
|
ServiceProviderContract.Exp! nsExp;
|
|
ServiceProviderContract.NewChannel(out nsImp, out nsExp);
|
|
|
|
try
|
|
{
|
|
ds.SendRegister(Bitter.FromString2(SeattleTrafficProxyContract.ModuleName), nsImp);
|
|
|
|
switch receive
|
|
{
|
|
case ds.AckRegister() :
|
|
// All is well.
|
|
break;
|
|
|
|
case ds.NakRegister(ServiceProviderContract.Imp:Start rejectedEP, error) :
|
|
// All is very much not well; abort.
|
|
Console.WriteLine("Failed to register the SeattleTraffic proxy module as " +
|
|
SeattleTrafficProxyContract.ModuleName);
|
|
delete nsExp;
|
|
delete rejectedEP;
|
|
return -1;
|
|
|
|
case ds.ChannelClosed():
|
|
Console.WriteLine("ds channel closed");
|
|
delete nsExp;
|
|
return -1;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
delete ds;
|
|
}
|
|
|
|
// Here is the set of client channels we service
|
|
ESet<SeattleTrafficProxyContract.Exp:ReadyState> epSet = new ESet<SeattleTrafficProxyContract.Exp:ReadyState>();
|
|
|
|
while(true)
|
|
{
|
|
switch receive
|
|
{
|
|
// ------------------------------- Requests for new connections
|
|
|
|
case nsExp.Connect(ServiceContract.Exp:Start! newEp) :
|
|
{
|
|
// We expect people top give us SeattleTrafficProxyContract.Exp instances
|
|
SeattleTrafficProxyContract.Exp newClient = newEp as SeattleTrafficProxyContract.Exp;
|
|
|
|
if (newClient == null)
|
|
{
|
|
// Invalid contract type. Fail.
|
|
nsExp.SendNackConnect(newEp);
|
|
}
|
|
else
|
|
{
|
|
// Signal ready and start servicing this contract
|
|
nsExp.SendAckConnect();
|
|
newClient.SendReady();
|
|
epSet.Add(newClient);
|
|
}
|
|
}
|
|
break;
|
|
|
|
// ------------------------------- Requests on existing connections
|
|
//
|
|
// Don't forget that we're selecting endpoints
|
|
// from the epSet endpoint-set. In each case that we
|
|
// receive a message from one of those endpoints, we
|
|
// need to remember to put the endpoint back into epSet
|
|
// if we want to keep listening to it.
|
|
//
|
|
case ep.GetTraffic() in epSet:
|
|
{
|
|
Console.WriteLine("SeattleTrafficProxy - received a GetTraffic request");
|
|
TrafficInfo[]! in ExHeap trafficInfo = LookupTraffic();
|
|
ep.SendTraffic(trafficInfo);
|
|
epSet.Add(ep);
|
|
}
|
|
break;
|
|
|
|
case nsExp.ChannelClosed() && epSet.Empty() :
|
|
// The namespace channel is closed and we have no more client
|
|
// channels, so pack up and go home.
|
|
delete nsExp;
|
|
epSet.Dispose();
|
|
return -1;
|
|
|
|
case ep.ChannelClosed() in epSet :
|
|
// Dispose of channels when our clients close them
|
|
delete ep;
|
|
break;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// HACK: LookupTraffic - This should leverage the Bayesian prediction work
|
|
// done by Eric Horvitz to retrieve traffic bottleneck times.
|
|
//
|
|
private static TrafficInfo[]! in ExHeap LookupTraffic()
|
|
{
|
|
// HACK: Disable until ready.
|
|
/*
|
|
try
|
|
{
|
|
using(WebClient webclient = new WebClient())
|
|
{
|
|
// Download traffic data
|
|
// TODO: Only download every five minutes.
|
|
webclient.DownloadFile(@"http://www.adapt.msresearch.us/smartphlow/Desktop/tip02.dat", "tip02.dat");
|
|
}
|
|
// Parse data
|
|
byte [] rawTraffic = ParseTipFile("tip02.dat");
|
|
|
|
// Generate the results for the client.
|
|
// TODO: Add more value to the traffic response.
|
|
TrafficInfo[]! in ExHeap trafficInfo = BuildTrafficInfo(rawTraffic);
|
|
return trafficInfo;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
}
|
|
*/
|
|
|
|
TrafficInfo[]! in ExHeap trafficInfo = new[ExHeap] TrafficInfo[12];
|
|
|
|
// West side
|
|
|
|
// 520 WB at Montlake
|
|
trafficInfo[0].minUntilFree = 6;
|
|
trafficInfo[0].latitude = 47.64574f;
|
|
trafficInfo[0].longitude = -122.30687f;
|
|
// 520 EB at Montlake
|
|
trafficInfo[1].minUntilFree = 30;
|
|
trafficInfo[1].latitude = 47.64314f;
|
|
trafficInfo[1].longitude = -122.30634f;
|
|
// 5 SB at Lake Union
|
|
trafficInfo[2].minUntilFree = 12;
|
|
trafficInfo[2].latitude = 47.63600f;
|
|
trafficInfo[2].longitude = -122.32949f;
|
|
// 5 NB at Lake Union
|
|
trafficInfo[3].minUntilFree = 27;
|
|
trafficInfo[3].latitude = 47.63519f;
|
|
trafficInfo[3].longitude = -122.32143f;
|
|
|
|
// East side
|
|
|
|
// 520 WB at bridge
|
|
trafficInfo[4].minUntilFree = 51;
|
|
trafficInfo[4].latitude = 47.64571f;
|
|
trafficInfo[4].longitude = -122.21226f;
|
|
// 520 EB at bridge
|
|
trafficInfo[5].minUntilFree = 0;
|
|
trafficInfo[5].latitude = 47.63983f;
|
|
trafficInfo[5].longitude = -122.20965f;
|
|
// 520 EB at Redmond
|
|
trafficInfo[6].minUntilFree = 22;
|
|
trafficInfo[6].latitude = 47.66538f;
|
|
trafficInfo[6].longitude = -122.11552f;
|
|
// 520 WB at Redmond
|
|
trafficInfo[7].minUntilFree = 0;
|
|
trafficInfo[7].latitude = 47.66986f;
|
|
trafficInfo[7].longitude = -122.13050f;
|
|
|
|
// 405 N in Bellevue
|
|
trafficInfo[8].minUntilFree = 39;
|
|
trafficInfo[8].latitude = 47.60998f;
|
|
trafficInfo[8].longitude = -122.18467f;
|
|
// 405 S in Bellevue
|
|
trafficInfo[9].minUntilFree = 16;
|
|
trafficInfo[9].latitude = 47.61012f;
|
|
trafficInfo[9].longitude = -122.19992f;
|
|
// 405 N in Kirkland
|
|
trafficInfo[10].minUntilFree = 14;
|
|
trafficInfo[10].latitude = 47.66809f;
|
|
trafficInfo[10].longitude = -122.18236f;
|
|
// 405 S in Kirkland
|
|
trafficInfo[11].minUntilFree = 9;
|
|
trafficInfo[11].latitude = 47.66761f;
|
|
trafficInfo[11].longitude = -122.19861f;
|
|
|
|
return trafficInfo;
|
|
}
|
|
}
|
|
}
|