public static DataServicePaxosProxy New(ProxyStateMachine stateMachine)
{
var resourcePresented = RoleEnvironment.GetConfigurationSettingValue(stateMachine.ServiceName + ".ResourcePresented");
var resourceManaged = RoleEnvironment.GetConfigurationSettingValue(stateMachine.ServiceName + ".ResourceManaged");
return(new DataServicePaxosProxy(resourceManaged, resourcePresented, stateMachine));
}
static void InitializeProxy(string service, string kind)
{
var location = RoleEnvironment.GetConfigurationSettingValue("Name");
try
{
var SM = ProxyStateMachine.New(location, service);
var RP = ProxyFactory.New(kind, SM);
FUSE.Weld.Azure.Configuration.SetConfigurationSettingPublisher();
var s2 = Utility.GetStorageAccount(true);
var container = s2.CreateCloudBlobClient().GetContainerReference("root");
container.CreateIfNotExist();
var logPosition = container.GetBlobReference(service + "LogPosition");
var startAt = 0;
try
{
startAt = Int32.Parse(logPosition.DownloadText());
}
catch
{
}
SM.StartAsync(startAt);
}
catch (ArgumentException ex)
{
if (!ex.Message.Contains("Location"))
{
throw;
}
}
}
DataServicePaxosProxy(string resourceManaged, string resourcePrestented, ProxyStateMachine stateMachine)
: base(resourceManaged, resourcePrestented, stateMachine.ServiceName)
{
var serviceName = stateMachine.ServiceName;
this.stateMachine = stateMachine;
this.stateMachine.GetResponse = base.GetResponse;
RouteTable.Routes.Add(new Route(serviceName + "/{*path}", new FuncRouteHandler(_ => this)));
}
public static ProxyBase New(string kind, ProxyStateMachine stateMachine)
{
if (kind.Equals("AzureStorage", StringComparison.InvariantCultureIgnoreCase))
{
return(AzureStorageProxy.New(stateMachine));
}
if (kind.Equals("DataService", StringComparison.InvariantCultureIgnoreCase))
{
return(DataServicePaxosProxy.New(stateMachine));
}
throw new ArgumentOutOfRangeException(kind + " is not a known service type");
}
AzureStorageProxy(string resourcePresented, ProxyStateMachine stateMachine)
: base(resourcePresented, stateMachine.ServiceName)
{
var serviceName = stateMachine.ServiceName;
this.stateMachine = stateMachine;
this.stateMachine.GetResponse = base.GetResponse;
this.ManagedAccount = RoleEnvironment.GetConfigurationSettingValue(serviceName + ".StorageAccount");
this.ManagedKey = RoleEnvironment.GetConfigurationSettingValue(serviceName + ".StorageKey");
this.PresentedAccount = RoleEnvironment.GetConfigurationSettingValue(serviceName + ".PresentedAccount");
this.PresentedKey = RoleEnvironment.GetConfigurationSettingValue(serviceName + ".PresentedKey");
this.prefix = serviceName;
this.stateMachine = stateMachine;
RouteTable.Routes.Add(new Route(serviceName + "/{*path}", new FuncRouteHandler(_ => this)));
}
public static ProxyStateMachine New(string location, string serviceName)
{
ProxyStateMachine stateMachine;
var nodeConfig = RoleEnvironment.GetConfigurationSettingValue(serviceName + ".Nodes");
var nodeDescriptors = nodeConfig.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
var nodes = new Dictionary <string, Uri>();
foreach (var d in nodeDescriptors)
{
var n = d.Split('=');
try
{
nodes.Add(n[0], new UriBuilder()
{
Host = n[1]
}.Uri);
}
catch (Exception x)
{
Trace.TraceError(x.ToString());
}
}
Uri host;
if (nodes.TryGetValue(location, out host))
{
var preferedLeaders = RoleEnvironment.GetConfigurationSettingValue(serviceName + ".PreferedActiveMembers").Split(';');
var localStorage = RoleEnvironment.GetLocalResource("LocalStorage").RootPath;
var storagePath = Path.Combine(localStorage, serviceName);
if (!Directory.Exists(storagePath))
{
Directory.CreateDirectory(storagePath);
}
var storage = new EsentStorage <string, SerialilzableWebRequest>(storagePath, new Counters(location));
var configuration = new Configuration <string>(preferedLeaders, preferedLeaders, nodes.Keys);
storage.TryInitialize(configuration);
Trace.WriteLine("Local Storage Initialized");
var meshPath = serviceName + "Mesh.ashx";
var uri = new UriBuilder(host)
{
Path = meshPath
}.Uri;
X509Certificate2 cert = Utility.GetCert();
var mesh = new MeshHandler <Message>(uri, null, cert);
RouteTable.Routes.Add(new Route(meshPath, new FuncRouteHandler(_ => mesh)));
FUSE.Weld.Azure.Configuration.SetConfigurationSettingPublisher();
var s2 = Utility.GetStorageAccount(true);
var container = s2.CreateCloudBlobClient().GetContainerReference("root");
container.CreateIfNotExist();
Trace.Write("Remote Storage Loaded");
stateMachine = new ProxyStateMachine(location, nodes, mesh, storage, serviceName, preferedLeaders);
stateMachine.Paxos.WhenDiverged.Subscribe(d =>
{
Utility.DisableService(stateMachine.ServiceName);
});
Global.lastMessages[serviceName] = new Queue <Timestamped <Tuple <string, Message, string> > >();
Global.stateMachines[serviceName] = stateMachine;
var o = stateMachine.Mesh
.Where(m => Interesting(m.Item2))
.Where(m => stateMachine.EndpointUrisToNames.ContainsKey(m.Item1))
.Select(m => Tuple.Create(stateMachine.EndpointUrisToNames[m.Item1], m.Item2, "To"))
.Timestamp();
var i = mesh
.Where(m => Interesting(m.Item2))
.Where(m => stateMachine.EndpointUrisToNames.ContainsKey(m.Item1))
.Select(m => Tuple.Create(stateMachine.EndpointUrisToNames[m.Item1], m.Item2, "From"))
.Timestamp();
i
.Merge(o)
.Subscribe(m =>
{
try
{
lock (Global.lastMessages)
{
var lastMessages = Global.lastMessages[serviceName];
lastMessages.Enqueue(m);
while (lastMessages.Count > 1000)
{
lastMessages.Dequeue();
}
}
}
catch
{
}
});
var enabled = false;
var enabledState = container.GetBlobReference(serviceName + "EnabledState.txt");
try
{
enabled = Boolean.Parse(enabledState.DownloadText());
}
catch
{
}
mesh.enabled = enabled;
return(stateMachine);
}
else
{
throw new ArgumentException("Location not found");
}
}
public static AzureStorageProxy New(ProxyStateMachine stateMachine)
{
var resource = RoleEnvironment.GetConfigurationSettingValue(stateMachine.ServiceName + ".ResourcePresented");
return(new AzureStorageProxy(resource, stateMachine));
}
