private void Configure(AzureServiceBusOwinServiceConfiguration config, Action<IAppBuilder> startup)
{
if (startup == null)
{
throw new ArgumentNullException("startup");
}
var options = new StartOptions();
if (string.IsNullOrWhiteSpace(options.AppStartup))
{
// Populate AppStartup for use in host.AppName
options.AppStartup = startup.Method.ReflectedType.FullName;
}
var testServerFactory = new AzureServiceBusOwinServerFactory(config);
var services = ServicesFactory.Create();
var engine = services.GetService<IHostingEngine>();
var context = new StartContext(options)
{
ServerFactory = new ServerFactoryAdapter(testServerFactory),
Startup = startup
};
_started = engine.Start(context);
_next = testServerFactory.Invoke;
}
public void FixtureSetup()
{
_server = WebApp.Start<Startup>(BASE_ADDRESS);
IHttwrapConfiguration configuration = new HttwrapConfiguration(BASE_ADDRESS);
_client = new HttwrapClient(configuration);
}
public ClientAnnotationViewModel(ISharedDataService sharedDataService, MeetingViewModel meeting) : base(sharedDataService, meeting)
{
// create the client annotations property, a mapped version of the agent's properties based on the screen sizes.
_annotationsChangedSub = _clientAnnotations = AnnotationsModel
.WhenAnyValue(v => v.Annotations, v => v.Select(p => CreateAnnotationViewModel(p)))
.ToProperty(this, v => v.Annotations);
}
public Task StopAsync()
{
this.signalrServer?.Dispose();
this.signalrServer = null;
return Task.CompletedTask;
}
public LightningQueuesChannel(Uri address, string queueName, Queue queueManager)
{
Address = address;
_queueName = queueName;
_queueManager = queueManager;
_disposable = Disposable.Empty;
}
public void Initialize(IDocument document)
{
if (this.document == null) {
this.document = document;
this.textDocument = (TextDocument)document.GetService(typeof(TextDocument));
this.changeList = new CompressingTreeList<LineChangeInfo>((x, y) => x.Equals(y));
}
var fileName = ((ITextEditor)document.GetService(typeof(ITextEditor))).FileName;
InitializeBaseDocument();
if (watcher != null)
watcher.Dispose();
if (usedProvider != null)
watcher = usedProvider.WatchBaseVersionChanges(fileName, HandleBaseVersionChanges);
SetupInitialFileState(fileName != currentFileName);
currentFileName = fileName;
if (!this.textDocument.LineTrackers.Contains(this)) {
this.textDocument.LineTrackers.Add(this);
this.textDocument.UndoStack.PropertyChanged += UndoStackPropertyChanged;
}
}
private static void Run()
{
if (Arguments.NumClients > 1)
{
AppHost = WebApp.Start<Startup>(Arguments.ControllerUrl);
if (!WaitForClientsToConnect())
{
SignalPhaseChange(ControllerEvents.Abort);
for (int attempts = 0; (ClientsConnected > 0) && (attempts < CrankArguments.ConnectionPollAttempts); attempts++)
{
Thread.Sleep(CrankArguments.ConnectionPollIntervalMS);
}
AppHost.Dispose();
return;
}
}
RunConnect();
RunSend();
RunDisconnect();
WaitForLastSamples();
if (AppHost != null)
{
AppHost.Dispose();
}
FlushLog(force:true);
}
public StateBucketService(ISettingsStore store)
{
var converter = new StateBucketConverter();
bool loading = false;
var writer = _cache.Connect()
.ToCollection()
.Select(buckets => converter.Convert(buckets.ToArray()))
.Subscribe(state =>
{
if (loading) return;
store.Save(SettingStoreKey, state);
});
//TODO: Make this error proof
var initialState = store.Load(SettingStoreKey);
var initialBuckets = converter.Convert(initialState);
try
{
loading = true;
_cache.AddOrUpdate(initialBuckets);
}
finally
{
loading = false;
}
_cleanUp = new CompositeDisposable(writer, _cache);
}
internal TestBlobCache(Action disposer,
IScheduler scheduler,
IEnumerable<KeyValuePair<string, byte[]>> initialContents)
: this(scheduler, initialContents)
{
inner = Disposable.Create(disposer);
}
public NodeViewModel(Node node, Vector location, IControlTypesResolver controlTypesResolver)
{
Node = node;
Title = node.Title;
Location = new CanvasPoint(location);
ControlTypesResolver = controlTypesResolver;
foreach (var pin in node.InputPins)
{
AddInputPin(pin);
}
foreach (var pin in node.OutputPins)
{
AddOutputPin(pin);
}
node.Processed += OnNodeProcessed;
node.PinsChanged += OnNodePinsChanged;
_disposable = Disposable.Create(() =>
{
node.PinsChanged -= OnNodePinsChanged;
node.Processed -= OnNodeProcessed;
});
}
public void Start()
{
var siteUrl = Settings.Default.SiteUrl;
var portNumber = Settings.Default.PortNumber;
var uri = $"http://*:{portNumber}{siteUrl}";
SmartDBEntities.SetConnection(Settings.Default.DBServer, Settings.Default.DBName,
Settings.Default.DBUser,
Encryption.Decrypt(Settings.Default.DBPassword));
Program.ProcessLog.Write("Database connection string to " + Settings.Default.DBServer +
" has successfully been made.");
if (SmartDBEntities.IsDBAvailable)
Program.ProcessLog.Write("Database connection " + Settings.Default.DBServer +
" has successfully been made.");
else
Program.ProcessLog.Write("Database connection " + Settings.Default.DBServer + " has failed.");
var options = new StartOptions();
#if DEBUG
options.Urls.Add($"http://{Environment.MachineName}:15000");
options.Urls.Add("http://localhost:15000/");
#endif
options.Urls.Add(uri);
Host = WebApp.Start<Startup>(options);
}
public void Dispose()
{
if(_storeSubscription == null)
return;
_storeSubscription.Dispose();
_storeSubscription = null;
_pluginChannel.Do(x => x.Value.Dispose());
_pluginChannel.Clear();
_pluginChannel = null;
_pluginServer.Do(x => x.Value.Dispose());
_pluginServer.Clear();
_pluginServer = null;
_pluginGlobal.Do(x => x.Value.Dispose());
_pluginGlobal.Clear();
_pluginGlobal = null;
_channel.Do(x => x.Value.Dispose());
_channel.Clear();
_channel = null;
_server.Do(x => x.Value.Dispose());
_server.Clear();
_server = null;
_global.Dispose();
_global = null;
}
public void OnStart()
{
server = WebApp.Start<Startup>("http://+:7774");
// TODO: Exception handling
Task.Factory.StartNew(() => provider = new PerformanceDataProvider());
}
public MDRefactoringScript (MDRefactoringContext context, CSharpFormattingOptions formattingOptions) : base(context.TextEditor.Document, formattingOptions, context.TextEditor.CreateNRefactoryTextEditorOptions ())
{
this.context = context;
undoGroup = this.context.TextEditor.OpenUndoGroup ();
this.startVersion = this.context.TextEditor.Version;
}
public Task StartTimer()
{
logger.Info("StartTimer.");
timer = base.RegisterTimer(TimerTick, null, TimeSpan.Zero, TimeSpan.FromSeconds(10));
return TaskDone.Done;
}
/// <summary>
/// sets the codec token to be used for video compression
/// </summary>
public void SetVideoCodecToken(IDisposable token)
{
if (token is CodecToken)
currVideoCodecToken = (CodecToken)token;
else
throw new ArgumentException("AviWriter only takes its own Codec Tokens!");
}
public void Start()
{
var siteUrl = Settings.Default.SiteUrl;
var portNumber = Settings.Default.PortNumber;
var uri = string.Format("http://*:{0}{1}", portNumber, siteUrl);
//SmartDBEntities.SetConnection(Settings.Default.DBServer, Settings.Default.DBName,
// Settings.Default.DBUser,
// Encryption.Decrypt(Settings.Default.DBPassword));
SupportCallManagerEntities.SetConnection(@"192.168.0.11\dev", "SupportCallManager",
Settings.Default.DBUser,
Encryption.Decrypt(Settings.Default.DBPassword));
Program.ProcessLog.Write("Database connection string to " + Settings.Default.DBServer + " has successfully been made.");
//if (SupportCallManagerEntities.IsDBAvailable)
// Program.ProcessLog.Write("Database connection " + Settings.Default.DBServer + " has successfully been made.");
//else
// Program.ProcessLog.Write("Database connection " + Settings.Default.DBServer + " has failed.");
StartOptions options = new StartOptions();
#if DEBUG
options.Urls.Add(string.Format("http://{0}:10000", Environment.MachineName));
options.Urls.Add("http://+:10000/");
options.Urls.Add("http://192.168.0.146:10000/");
#endif
options.Urls.Add(uri);
host = WebApp.Start<Startup>(options);
}
public void Initialize()
{
try
{
HostingEnvironment.RegisterObject(this);
// Normally when the AppDomain shuts down IRegisteredObject.Stop gets called, except that
// ASP.NET waits for requests to end before calling IRegisteredObject.Stop. This can be
// troublesome for some frameworks like SignalR that keep long running requests alive.
// These are more aggressive checks to see if the app domain is in the process of being shutdown and
// we trigger the same cts in that case.
if (HttpRuntime.UsingIntegratedPipeline)
{
if (RegisterForStopListeningEvent())
{
}
else if (UnsafeIISMethods.CanDetectAppDomainRestart)
{
// Create a timer for polling when the app pool has been requested for shutdown.
#if NET40
// Use the existing timer
_checkAppPoolTimer = SharedTimer.StaticTimer.Register(CheckForAppDomainRestart, state: null);
#else
_checkAppPoolTimer = new Timer(CheckForAppDomainRestart, state: null,
dueTime: TimeSpan.FromSeconds(10), period: TimeSpan.FromSeconds(10));
#endif
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
protected override void OnInitialize()
{
base.OnInitialize();
var _ecgObservable = EcgSimulator.SimulateEcgAsObservable();
_disposable = _ecgObservable.Subscribe(s => Debug.WriteLine(s));
}
/// <summary>
/// Creates a new group containing two disposable resources that are disposed together.
/// </summary>
/// <param name="disposable1">The first disposable resoruce to add to the group.</param>
/// <param name="disposable2">The second disposable resoruce to add to the group.</param>
/// <returns>Group of disposable resources that are disposed together.</returns>
public static ICancelable Create(IDisposable disposable1, IDisposable disposable2)
{
if (disposable1 == null) throw new ArgumentNullException("disposable1");
if (disposable2 == null) throw new ArgumentNullException("disposable2");
return new Binary(disposable1, disposable2);
}
// global instances that keep controller and windows service alive
public void Start(QueueMessageManager manager = null)
{
if (manager == null)
manager = new QueueMessageManagerSql();
LogManager.Current.LogInfo("Start called");
var config = QueueMessageManagerConfiguration.Current;
Controller = new QueueController()
{
ConnectionString = config.ConnectionString,
QueueName = config.QueueName,
WaitInterval = config.WaitInterval,
ThreadCount = config.ControllerThreads
};
LogManager.Current.LogInfo("Controller created.");
// asynchronously start the SignalR hub
SignalR = WebApplication.Start<SignalRStartup>("http://*:8080/");
// *** Spin up n Number of threads to process requests
Controller.StartProcessingAsync();
LogManager.Current.LogInfo(String.Format("QueueManager Controller Started with {0} threads.",
Controller.ThreadCount));
// Set static instances so that these 'services' stick around
GlobalService.Controller = Controller;
GlobalService.Service = this;
}
public ConfigHandler()
{
_binder = SwitchXmlSearchBinding.Bind(XmlCallback,
switch_xml_section_enum_t.SWITCH_XML_SECTION_DIRECTORY |
switch_xml_section_enum_t.SWITCH_XML_SECTION_DIALPLAN);
}
public VirtualListVewModel(SynchronizationContext bindingContext, DataService service)
{
_virtualRequest = new BehaviorSubject<VirtualRequest>(new VirtualRequest(0,10));
Items = new BindingList<Poco>();
var sharedDataSource = service
.DataStream
.Do(x => Trace.WriteLine($"Service -> {x}"))
.ToObservableChangeSet()
.Publish();
var binding = sharedDataSource
.Virtualise(_virtualRequest)
.ObserveOn(bindingContext)
.Bind(Items)
.Subscribe();
//the problem was because Virtualise should fire a noticiation if count changes, but it does not [BUG]
//Therefore take the total count from the underlying data NB: Count is DD.Count() not Observable.Count()
Count = sharedDataSource.Count().DistinctUntilChanged();
Count.Subscribe(x => Trace.WriteLine($"Count = {x}"));
var connection = sharedDataSource.Connect();
_disposables = new CompositeDisposable(binding, connection);
}
public bool BeginTransaction ()
{
if (inTransaction)
throw new InvalidOperationException ("Already in a transaction");
transactionLock = LockWrite ();
try {
updatingLock = new FileStream (UpdateDatabaseLockFile, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
} catch (IOException) {
// The database is already being updated. Can't do anything for now.
return false;
} finally {
transactionLock.Dispose ();
}
// Delete .new files that could have been left by an aborted database update
transactionLock = LockRead ();
CleanDirectory (rootDirectory);
inTransaction = true;
foldersToUpdate = new Hashtable ();
deletedFiles = new Hashtable ();
deletedDirs = new Hashtable ();
return true;
}
public static void Open(params string[] hostUrls)
{
try
{
if (_CloseOWin == null)
{
// Start OWIN host
StartOptions so = new StartOptions();
foreach (string s in hostUrls)
{
so.Urls.Add(s);
}
_CloseOWin = WebApp.Start<SNStartup>(so);
}
}
catch (Exception ex)
{
if (ex.InnerException is System.Net.HttpListenerException)
{
throw new Exception("监听IP有错误");
}
if (_CloseOWin != null)
{
_CloseOWin.Dispose();//必须
_CloseOWin = null;//必须
}
throw;
}
}
public AggregationViewModel()
{
var sourceList = new SourceList<AggregationItem>();
sourceList.AddRange(Enumerable.Range(1, 15).Select(i => new AggregationItem(i)));
//Load items to display to user and allow them to include items or not
var listLoader = sourceList.Connect()
.Sort(SortExpressionComparer<AggregationItem>.Ascending(vm => vm.Number))
.ObserveOnDispatcher()
.Bind(out _items)
.Subscribe();
// share the connection because we are doing multiple aggregations
var aggregatable = sourceList.Connect()
.FilterOnProperty(vm => vm.IncludeInTotal, vm => vm.IncludeInTotal)
.Publish();
//Do a custom aggregation (ToCollection() produces a readonly collection of underlying data)
var sumOfOddNumbers = aggregatable.ToCollection()
.Select(collection => collection.Where(i => i.Number%2 == 1).Select(ai => ai.Number).Sum())
.Subscribe(sum => SumOfOddNumbers = sum);
_cleanUp = new CompositeDisposable(sourceList,
listLoader,
aggregatable.Count().Subscribe(count => Count = count),
aggregatable.Sum(ai => ai.Number).Subscribe(sum => Sum = sum),
aggregatable.Avg(ai => ai.Number).Subscribe(average => Avg = Math.Round(average,2)),
aggregatable.Minimum(ai => ai.Number).Subscribe(max => Max = max),
aggregatable.Maximum(ai => ai.Number).Subscribe(min => Min = min),
aggregatable.StdDev(ai => ai.Number).Subscribe(std => StdDev = Math.Round(std, 2)),
sumOfOddNumbers,
aggregatable.Connect());
}
public void Add(IDisposable component)
{
if (component != null)
{
this.components.Add(component);
}
}
/// <summary>
/// Initializes a new instance of the <see cref = "ItemAutoSubscription" /> class.
/// </summary>
/// <param name = "item">
/// The subscribed item.
/// </param>
/// <param name = "itemPosition">
/// The item position.
/// </param>
/// <param name = "itemRegion">
/// The item Region.
/// </param>
/// <param name = "subscription">
/// The subscription.
/// </param>
public ItemAutoSubscription(Item item, Vector itemPosition, Region itemRegion, IDisposable subscription)
{
this.ItemPosition = itemPosition;
this.item = item;
this.subscription = subscription;
this.WorldRegion = itemRegion;
}
/// <summary>
/// Initializes a new instance of the <see cref="SPOEmulationContext"/> class.
/// </summary>
/// <param name="isolationLevel">The level.</param>
/// <param name="connectionInformation">The connection informations for the target web.</param>
public SPOEmulationContext(IsolationLevel isolationLevel, ConnectionInformation connectionInformation)
{
this._isolationLevel = isolationLevel;
switch (isolationLevel)
{
case IsolationLevel.Fake:
// create shim context
_shimsContext = ShimsContext.Create();
// initialize all simulated types
_clientContext = InitializeSimulatedAPI(connectionInformation.Url);
break;
case IsolationLevel.Integration:
// create shim context
_shimsContext = ShimsContext.Create();
Connect(connectionInformation);
break;
case IsolationLevel.None:
Connect(connectionInformation);
break;
default:
throw new InvalidOperationException();
}
}
public void Connect(IEventStream stream)
{
subscription = stream.Of<IEventPattern<IDevice, ISensed>>().Subscribe(sensed =>
{
var type = topicRegistry.Find(sensed.EventArgs.Topic);
switch (type)
{
case TopicType.Boolean:
stream.Push(sensed.Sender, Impulse.Create(sensed.EventArgs.Topic, Payload.ToBoolean(sensed.EventArgs.Payload), clock.Now));
break;
case TopicType.Number:
stream.Push(sensed.Sender, Impulse.Create(sensed.EventArgs.Topic, Payload.ToNumber(sensed.EventArgs.Payload), clock.Now));
break;
case TopicType.String:
stream.Push(sensed.Sender, Impulse.Create(sensed.EventArgs.Topic, Payload.ToString(sensed.EventArgs.Payload), clock.Now));
break;
case TopicType.Void:
stream.Push(sensed.Sender, Impulse.Create(sensed.EventArgs.Topic, Unit.Default, clock.Now));
break;
case TopicType.Unknown:
default:
// TODO: throw? Report?
break;
}
});
}
internal unsafe MemoryMappedFileBlock(IDisposable accessor, SafeBuffer safeBuffer, long offset, int size)
{
_data = new DisposableData(accessor, safeBuffer, offset);
_size = size;
}
public CarefulAccount(Log log, IResolverContext scope) : base(log)
{
_scope = scope;
}
public ObserveOn(ObserveOnObservable <T> parent, IObserver <T> observer, IDisposable cancel) : base(observer, cancel)
{
this.parent = parent;
}
public IDisposable Run()
{
IDisposable sourceDisposable = parent.source.Subscribe(this);
return(StableCompositeDisposable.Create(sourceDisposable, isDisposed));
}
public ObserveOn_(ObserveOnObservable <T> parent, ISchedulerQueueing scheduler, IObserver <T> observer, IDisposable cancel) : base(observer, cancel)
{
this.parent = parent;
this.scheduler = scheduler;
this.isDisposed = new BooleanDisposable();
this.onNext = new Action <T>(OnNext_); // cache delegate
}
public SearchOptionsProxy([NotNull] SearchMetadata searchMetadata,
[NotNull] IColourProvider colourProvider,
[NotNull] IThemeProvider themeProvider,
[NotNull] IconSelector iconSelector,
[NotNull] Action <SearchMetadata> removeAction,
[NotNull] IDefaultIconSelector defaultIconSelector,
Guid parentId)
{
if (searchMetadata == null)
{
throw new ArgumentNullException(nameof(searchMetadata));
}
if (colourProvider == null)
{
throw new ArgumentNullException(nameof(colourProvider));
}
if (themeProvider == null)
{
throw new ArgumentNullException(nameof(themeProvider));
}
if (iconSelector == null)
{
throw new ArgumentNullException(nameof(iconSelector));
}
if (removeAction == null)
{
throw new ArgumentNullException(nameof(removeAction));
}
if (defaultIconSelector == null)
{
throw new ArgumentNullException(nameof(defaultIconSelector));
}
_searchMetadata = searchMetadata;
_defaultIconSelector = defaultIconSelector;
IconSelector = iconSelector;
ParentId = parentId;
Highlight = _searchMetadata.Highlight;
Filter = _searchMetadata.Filter;
UseRegex = searchMetadata.UseRegex;
IgnoreCase = searchMetadata.IgnoreCase;
Position = searchMetadata.Position;
Hues = colourProvider.Hues;
HighlightHue = searchMetadata.HighlightHue;
ShowIconSelectorCommand = new Command(ShowIconSelector);
RemoveCommand = new Command(() => removeAction(searchMetadata));
HighlightCommand = new Command <Hue>(newHue =>
{
HighlightHue = newHue;
});
IconKind = _searchMetadata.IconKind.ParseEnum <PackIconKind>()
.ValueOr(() => PackIconKind.ArrowRightBold);
//combine system with user choice.
var defaultHue = this.WhenValueChanged(vm => vm.HighlightHue)
.CombineLatest(themeProvider.Accent, (user, system) => user == Hue.NotSpecified ? system : user).Publish();
Foreground = defaultHue.Select(h => h.ForegroundBrush).ForBinding();
Background = defaultHue.Select(h => h.BackgroundBrush).ForBinding();
_cleanUp = new CompositeDisposable(IconSelector, Foreground, Background, defaultHue.Connect());
}
public void AddDisposable(IDisposable disposable)
{
_disposables.Add(disposable);
}
/// <summary>
/// Inicializa una nueva instancia de la clase <see cref="RequestServer"/>
/// </summary>
/// <param name="baseAddress">String que indica la dirección en la que se van a encontrar los controladores</param>
public RequestServer(string baseAddress)
{
this.baseAddress = string.Format("http://*:5800/{0},https://*:5801/{0}", baseAddress);
httpServiceHost = StartHttp();
}
public _(GroupByUntil <TSource, TKey, TElement, TDuration> parent, IObserver <IGroupedObservable <TKey, TElement> > observer, IDisposable cancel)
: base(observer, cancel)
{
_parent = parent;
_map = new Map <TKey, ISubject <TElement> >(_parent._capacity, _parent._comparer);
_nullGate = new object();
}
public L(K k, IResolverContext scope)
{
K = k;
Scope = scope;
}
public void Security_AuthorizeEndpointTests(HostType hostType)
{
using (ApplicationDeployer deployer = new ApplicationDeployer())
{
var applicationUrl = deployer.Deploy(hostType, AuthServerHappyPathConfiguration);
IDisposable clientEndpoint = null;
try
{
clientEndpoint = WebApp.Start(Client_Redirect_Uri, app => app.Run(context => { return(context.Response.WriteAsync(context.Request.QueryString.Value)); }));
string tokenEndpointUri = applicationUrl + "TokenEndpoint";
var basicClient = new HttpClient();
var headerValue = Convert.ToBase64String(Encoding.Default.GetBytes(string.Format("{0}:{1}", "123", "invalid")));
basicClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", headerValue);
HttpClient httpClient = new HttpClient();
string requestUri = null;
Uri landingUri = null;
Uri applicationUri = new Uri(applicationUrl);
HttpResponseMessage httpResponseMessage = null;
//Happy path - response_type:code
requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", Client_Redirect_Uri, "scope1", "validstate");
landingUri = httpClient.GetAsync(requestUri).Result.RequestMessage.RequestUri;
Assert.Equal <string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path));
Assert.NotNull(landingUri.ParseQueryString()["code"]);
Assert.Equal <string>("validstate", landingUri.ParseQueryString()["state"]);
//Happy path - response_type:token
requestUri = AuthZ.CreateAuthZUri(applicationUrl, "token", "123", Client_Redirect_Uri, "scope1", "validstate");
landingUri = httpClient.GetAsync(requestUri).Result.RequestMessage.RequestUri;
landingUri = new Uri(landingUri.AbsoluteUri.Replace('#', '?'));
Assert.Equal <string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path));
Assert.NotNull(landingUri.ParseQueryString()["access_token"]);
Assert.NotNull(landingUri.ParseQueryString()["expires_in"]);
Assert.Equal <string>("bearer", landingUri.ParseQueryString()["token_type"]);
Assert.Equal <string>("validstate", landingUri.ParseQueryString()["state"]);
//Invalid redirect URI - pass error to application
requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", "invalid_uri_passonerror", "scope1", "validstate");
httpResponseMessage = httpClient.GetAsync(requestUri).Result;
Assert.Equal <string>("error: invalid_request\r\n", httpResponseMessage.Content.ReadAsStringAsync().Result);
Assert.True(httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Authority).StartsWith(applicationUri.GetLeftPart(UriPartial.Authority)), "Should not be redirected on invalid redirect_uri");
//Invalid redirect URI - Display error by middleware
requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", "invalid_uri_displayerror", "scope1", "validstate");
httpResponseMessage = httpClient.GetAsync(requestUri).Result;
Assert.True(httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Authority).StartsWith(applicationUri.GetLeftPart(UriPartial.Authority)), "Should not be redirected on invalid redirect_uri");
Assert.True(httpResponseMessage.Content.ReadAsStringAsync().Result.StartsWith("error: invalid_request"), "Did not receive an error for an invalid redirect_uri");
//What happens if we don't set Validated explicitly. Send an invalid clientId => We don't set Validated for this case.
requestUri = AuthZ.CreateAuthZUri(applicationUrl, "token", "invalidClient", Client_Redirect_Uri, "scope1", "validstate");
httpResponseMessage = httpClient.GetAsync(requestUri).Result;
Assert.True(httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Authority).StartsWith(applicationUri.GetLeftPart(UriPartial.Authority)), "Should not be redirected on invalid redirect_uri");
Assert.True(httpResponseMessage.Content.ReadAsStringAsync().Result.StartsWith("error: invalid_request"), "Did not receive an error for an invalid redirect_uri");
//OnValidateAuthorizeRequest - Rejecting a request. Send an invalid state as we validate it there. Client should receive all the error code & description that we send
requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", Client_Redirect_Uri, "scope1", "invalidstate");
httpResponseMessage = httpClient.GetAsync(requestUri).Result;
landingUri = httpResponseMessage.RequestMessage.RequestUri;
Assert.Equal <string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path));
Assert.Equal <string>("state.invalid", landingUri.ParseQueryString()["error"]);
Assert.Equal <string>("state.invaliddescription", landingUri.ParseQueryString()["error_description"]);
Assert.Equal <string>("state.invaliduri", landingUri.ParseQueryString()["error_uri"]);
Assert.True(httpResponseMessage.Content.ReadAsStringAsync().Result.StartsWith("error=state.invalid&error_description=state.invaliddescription&error_uri=state.invaliduri"), "Did not receive an error when provider did not set Validated");
//Missing response_type
requestUri = AuthZ.CreateAuthZUri(applicationUrl, null, "123", Client_Redirect_Uri, "scope1", "validstate");
httpResponseMessage = httpClient.GetAsync(requestUri).Result;
Assert.Equal <string>(Client_Redirect_Uri, httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Path));
Assert.Equal <string>("invalid_request", httpResponseMessage.RequestMessage.RequestUri.ParseQueryString()["error"]);
//Unsupported response_type
requestUri = AuthZ.CreateAuthZUri(applicationUrl, "invalid_response_type", "123", Client_Redirect_Uri, "scope1", "validstate");
httpResponseMessage = httpClient.GetAsync(requestUri).Result;
Assert.Equal <string>(Client_Redirect_Uri, httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Path));
Assert.Equal <string>("unsupported_response_type", httpResponseMessage.RequestMessage.RequestUri.ParseQueryString()["error"]);
//Missing client_id
requestUri = AuthZ.CreateAuthZUri(applicationUrl, "token", null, Client_Redirect_Uri, "scope1", "validstate");
httpResponseMessage = httpClient.GetAsync(requestUri).Result;
Assert.True(httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Authority).StartsWith(applicationUri.GetLeftPart(UriPartial.Authority)), "Should not be redirected on invalid redirect_uri");
Assert.True(httpResponseMessage.Content.ReadAsStringAsync().Result.StartsWith("error: invalid_request"), "Did not receive an error for an invalid redirect_uri");
//Missing state - Should succeed
requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", Client_Redirect_Uri, "scope1", null);
landingUri = httpClient.GetAsync(requestUri).Result.RequestMessage.RequestUri;
Assert.Equal <string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path));
Assert.NotNull(landingUri.ParseQueryString()["code"]);
Assert.Equal <bool>(false, landingUri.ParseQueryString().ContainsKey("state"));
//Token endpoint tests
//Invalid client (client_id, client_secret) - As form parameters
var formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "invalid") });
var responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result;
var jToken = JToken.Parse(responseMessage);
Assert.Equal <string>("invalid_client", jToken.SelectToken("error").Value <string>());
//Invalid client (client_id, client_secret) - As Basic auth headers
responseMessage = basicClient.GetAsync(tokenEndpointUri).Result.Content.ReadAsStringAsync().Result;
jToken = JToken.Parse(responseMessage);
Assert.Equal <string>("invalid_client", jToken.SelectToken("error").Value <string>());
//grant_type=authorization_code - invalid code being sent
formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "authorization_code"), new kvp("code", "InvalidCode"), new kvp("redirect_uri", Client_Redirect_Uri) });
responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result;
jToken = JToken.Parse(responseMessage);
Assert.Equal <string>("invalid_grant", jToken.SelectToken("error").Value <string>());
//grant_type=authorization_code - Full scenario
requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", Client_Redirect_Uri, "scope1", "validstate");
landingUri = httpClient.GetAsync(requestUri).Result.RequestMessage.RequestUri;
Assert.Equal <string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path));
Assert.NotNull(landingUri.ParseQueryString()["code"]);
Assert.Equal <string>("validstate", landingUri.ParseQueryString()["state"]);
formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "authorization_code"), new kvp("code", landingUri.ParseQueryString()["code"]), new kvp("redirect_uri", Client_Redirect_Uri) });
responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result;
jToken = JToken.Parse(responseMessage);
Assert.NotNull(jToken.SelectToken("access_token").Value <string>());
Assert.Equal <string>("bearer", jToken.SelectToken("token_type").Value <string>());
Assert.NotNull(jToken.SelectToken("expires_in").Value <string>());
Assert.Equal <string>("value1", jToken.SelectToken("param1").Value <string>());
Assert.Equal <string>("value2", jToken.SelectToken("param2").Value <string>());
Assert.NotNull(jToken.SelectToken("refresh_token").Value <string>());
//grant_type=password -- Resource owner credentials -- Invalid credentials
formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "password"), new kvp("username", "user1"), new kvp("password", "invalid"), new kvp("scope", "scope1 scope2 scope3") });
responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result;
jToken = JToken.Parse(responseMessage);
Assert.Equal <string>("invalid_grant", jToken.SelectToken("error").Value <string>());
//grant_type=password -- Resource owner credentials
formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "password"), new kvp("username", "user1"), new kvp("password", "password1"), new kvp("scope", "scope1 scope2 scope3") });
responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result;
jToken = JToken.Parse(responseMessage);
Assert.NotNull(jToken.SelectToken("access_token").Value <string>());
Assert.Equal <string>("bearer", jToken.SelectToken("token_type").Value <string>());
Assert.NotNull(jToken.SelectToken("expires_in").Value <string>());
Assert.Equal <string>("value1", jToken.SelectToken("param1").Value <string>());
Assert.Equal <string>("value2", jToken.SelectToken("param2").Value <string>());
Assert.NotNull(jToken.SelectToken("refresh_token").Value <string>());
//grant_type=refresh_token -- Use the refresh token issued on the previous call
formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "refresh_token"), new kvp("refresh_token", jToken.SelectToken("refresh_token").Value <string>()), new kvp("scope", "scope1 scope2") });
responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result;
jToken = JToken.Parse(responseMessage);
Assert.NotNull(jToken.SelectToken("access_token").Value <string>());
Assert.Equal <string>("bearer", jToken.SelectToken("token_type").Value <string>());
Assert.NotNull(jToken.SelectToken("expires_in").Value <string>());
Assert.Equal <string>("value1", jToken.SelectToken("param1").Value <string>());
Assert.Equal <string>("value2", jToken.SelectToken("param2").Value <string>());
Assert.NotNull(jToken.SelectToken("refresh_token").Value <string>());
//grant_type=client_credentials - Bug# https://github.com/Katana/katana/issues/562
formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "client_credentials"), new kvp("scope", "scope1 scope2 scope3") });
responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result;
jToken = JToken.Parse(responseMessage);
Assert.NotNull(jToken.SelectToken("access_token").Value <string>());
Assert.Equal <string>("bearer", jToken.SelectToken("token_type").Value <string>());
Assert.NotNull(jToken.SelectToken("expires_in").Value <string>());
Assert.Equal <string>("value1", jToken.SelectToken("param1").Value <string>());
Assert.Equal <string>("value2", jToken.SelectToken("param2").Value <string>());
}
finally
{
//Finally close the client endpoint
if (clientEndpoint != null)
{
clientEndpoint.Dispose();
}
}
}
}
protected override IDisposable Run(IObserver <IGroupedObservable <TKey, TElement> > observer, IDisposable cancel, Action <IDisposable> setSink)
{
_groupDisposable = new CompositeDisposable();
_refCountDisposable = new RefCountDisposable(_groupDisposable);
var sink = new _(this, observer, cancel);
setSink(sink);
_groupDisposable.Add(_source.SubscribeSafe(sink));
return(_refCountDisposable);
}
void DoDuplicateUrl(string url)
{
var tests = new DupeUrlTest[] {
new DupeUrlTest(
null,
() => Factory.PublisherCreate(url).Unwrap(),
false),
new DupeUrlTest(
null,
() => Factory.PullerCreate(url, true).Unwrap(),
false),
new DupeUrlTest(
() => Factory.PusherCreate(url, true).Unwrap(),
() => Factory.PullerCreate(url, false).Unwrap(),
true),
new DupeUrlTest(
null,
() => Factory.PusherCreate(url, true).Unwrap(),
false),
new DupeUrlTest(
() => Factory.PullerCreate(url, true).Unwrap(),
() => Factory.PusherCreate(url, false).Unwrap(),
true),
new DupeUrlTest(
null,
() => Factory.ReplierCreate(url).Unwrap(),
false),
new DupeUrlTest(
() => Factory.ReplierCreate(url).Unwrap(),
() => Factory.RequesterCreate(url).Unwrap(),
true),
new DupeUrlTest(
() => Factory.PublisherCreate(url).Unwrap(),
() => Factory.SubscriberCreate(url).Unwrap(),
true),
};
for (int i = 0; i < tests.Length; ++i)
{
var test = tests[i];
IDisposable pre = null;
IDisposable obj0 = null;
IDisposable obj1 = null;
try
{
if (test.pre != null)
{
pre = test.pre.Invoke();
Assert.NotNull(pre);
}
obj0 = test.func();
if (test.isOk)
{
obj1 = test.func();
Assert.NotNull(obj1);
}
else
{
Assert.ThrowsAny <Exception>(() => obj1 = test.func());
}
}
finally
{
pre?.Dispose();
obj0?.Dispose();
obj1?.Dispose();
}
}
}
public void TestInitialize()
{
_shimObject = ShimsContext.Create();
}
private ClientRequestActivity()
{
_relatedActivityId = ActivityStack.Id;
_popWhenDispose = ActivityStack.Push(_activityId);
}
public override Expression VisitSelect(SelectExpression selectExpression)
{
Check.NotNull(selectExpression, nameof(selectExpression));
IDisposable subQueryIndent = null;
if (selectExpression.Alias != null)
{
_rcbsql.AppendLine("(");
subQueryIndent = _rcbsql.Indent();
}
_rcbsql.Append("SELECT ");
var projectionAdded = false;
if (selectExpression.IsProjectStar)
{
_rcbsql.Append("*");
projectionAdded = true;
}
if (selectExpression.Projection.Count > 0)
{
if (selectExpression.IsProjectStar)
{
_rcbsql.Append(", ");
}
for (int i = 0; i < selectExpression.Projection.Count; i++)
{
var col = (ColumnExpression)selectExpression.Projection[i];
_rcbsql.Append($"{col.Name} ");
if (i < selectExpression.Projection.Count - 1)
{
_rcbsql.Append(", ");
}
}
projectionAdded = true;
}
if (!projectionAdded)
{
_rcbsql.Append("1");
}
if (selectExpression.Tables.Count > 0)
{
_rcbsql.AppendLine()
.Append("FROM ");
GenerateList(selectExpression.Tables, tx =>
{
var te = ((TableExpression)tx);
var schema = string.IsNullOrEmpty(te.Schema) ? __taosConnectionStringBuilder.DataBase : te.Schema;
_rcbsql.Append($"{schema}.{te.Table}");
}, null);
}
else
{
GeneratePseudoFromClause();
}
if (selectExpression.Predicate != null)
{
GeneratePredicate(selectExpression.Predicate);
}
if (selectExpression.GroupBy.Count > 0)
{
_rcbsql.AppendLine();
_rcbsql.Append("GROUP BY ");
GenerateList(selectExpression.GroupBy);
}
if (selectExpression.Having != null)
{
GenerateHaving(selectExpression.Having);
}
if (selectExpression.OrderBy.Count > 0)
{
var orderByList = new List <Ordering>(selectExpression.OrderBy);
// Filter out constant and parameter expressions (SELECT 1) if there is no skip or take #10410
if (selectExpression.Limit == null && selectExpression.Offset == null)
{
// orderByList.RemoveAll(o => IsOrderByExpressionConstant(ApplyOptimizations(o.Expression, searchCondition: false)));
}
if (orderByList.Count > 0)
{
_rcbsql.AppendLine();
GenerateOrderBy(orderByList);
}
}
GenerateLimitOffset(selectExpression);
if (subQueryIndent != null)
{
subQueryIndent.Dispose();
_rcbsql.AppendLine()
.Append(")");
if (selectExpression.Alias.Length > 0)
{
_rcbsql
.Append(AliasSeparator)
.Append(SqlGenerator.DelimitIdentifier(selectExpression.Alias));
}
}
return(selectExpression);
}
public void Start(int interval)
{
var task = Observable.Timer(TimeSpan.Zero, TimeSpan.FromHours(interval));
subscription = task.Subscribe(DownloadImage);
}
public void Stop()
{
subscription.Dispose();
subscription = null;
}
/// <summary>
/// Take responsibility for a new queues that was assigned to me via a new range.
/// We first store the new queue in our internal data structure, try to initialize it and start a pumping timer.
/// ERROR HANDLING:
/// The resposibility to handle initializatoion and shutdown failures is inside the INewQueueAdapterReceiver code.
/// The agent will call Initialize once and log an error. It will not call initiliaze again.
/// The receiver itself may attempt later to recover from this error and do initialization again.
/// The agent will assume initialization has succeeded and will subsequently start calling pumping receive.
/// Same applies to shutdown.
/// </summary>
/// <param name="qAdapter"></param>
/// <param name="queueAdapterCache"></param>
/// <param name="failureHandler"></param>
/// <returns></returns>
public async Task Initialize(Immutable <IQueueAdapter> qAdapter, Immutable <IQueueAdapterCache> queueAdapterCache, Immutable <IStreamFailureHandler> failureHandler)
{
if (qAdapter.Value == null)
{
throw new ArgumentNullException("qAdapter", "Init: queueAdapter should not be null");
}
if (failureHandler.Value == null)
{
throw new ArgumentNullException("failureHandler", "Init: streamDeliveryFailureHandler should not be null");
}
logger.Info(ErrorCode.PersistentStreamPullingAgent_02, "Init of {0} {1} on silo {2} for queue {3}.",
GetType().Name, GrainId.ToDetailedString(), Silo, QueueId.ToStringWithHashCode());
// Remove cast once we cleanup
queueAdapter = qAdapter.Value;
streamFailureHandler = failureHandler.Value;
lastTimeCleanedPubSubCache = DateTime.UtcNow;
try
{
receiver = queueAdapter.CreateReceiver(QueueId);
}
catch (Exception exc)
{
logger.Error(ErrorCode.PersistentStreamPullingAgent_02, "Exception while calling IQueueAdapter.CreateNewReceiver.", exc);
return;
}
try
{
if (queueAdapterCache.Value != null)
{
queueCache = queueAdapterCache.Value.CreateQueueCache(QueueId);
}
}
catch (Exception exc)
{
logger.Error(ErrorCode.PersistentStreamPullingAgent_23, "Exception while calling IQueueAdapterCache.CreateQueueCache.", exc);
return;
}
try
{
var task = OrleansTaskExtentions.SafeExecute(() => receiver.Initialize(config.InitQueueTimeout));
task = task.LogException(logger, ErrorCode.PersistentStreamPullingAgent_03, String.Format("QueueAdapterReceiver {0} failed to Initialize.", QueueId.ToStringWithHashCode()));
await task;
}
catch
{
// Just ignore this exception and proceed as if Initialize has succeeded.
// We already logged individual exceptions for individual calls to Initialize. No need to log again.
}
// Setup a reader for a new receiver.
// Even if the receiver failed to initialise, treat it as OK and start pumping it. It's receiver responsibility to retry initialization.
var randomTimerOffset = safeRandom.NextTimeSpan(config.GetQueueMsgsTimerPeriod);
timer = base.RegisterTimer(AsyncTimerCallback, QueueId, randomTimerOffset, config.GetQueueMsgsTimerPeriod);
logger.Info((int)ErrorCode.PersistentStreamPullingAgent_04, "Taking queue {0} under my responsibility.", QueueId.ToStringWithHashCode());
}
/// <summary>
/// Subscribes to progress reports.
/// </summary>
/// <param name="id">The identifier.</param>
/// <param name="disposables">The disposables.</param>
/// <param name="mergeType">Type of the merge.</param>
protected virtual void SubscribeToProgressReports(long id, CompositeDisposable disposables, MergeType mergeType)
{
fileMergeProgressHandler?.Dispose();
modCompressProgressHandler?.Dispose();
freeSpaceCheckHandler?.Dispose();
freeSpaceCheckHandler = modMergeFreeSpaceCheckHandler.Subscribe(s =>
{
var message = localizationManager.GetResource(LocalizationResources.Collection_Mods.MergeCollection.DiskInfoOverlay);
var overlayProgress = Smart.Format(localizationManager.GetResource(LocalizationResources.Collection_Mods.MergeCollection.Overlay_Progress), new
{
PercentDone = s.Percentage.ToLocalizedPercentage(),
Count = 1,
TotalCount = 3
});
TriggerOverlay(id, true, message, overlayProgress);
}).DisposeWith(disposables);
if (mergeType == MergeType.Basic)
{
fileMergeProgressHandler = modFileMergeProgressHandler.Subscribe(s =>
{
string message;
if (s.Step == 1)
{
message = localizationManager.GetResource(LocalizationResources.Collection_Mods.MergeCollection.Basic.Overlay_Gathering_Mod_Info);
}
else
{
message = localizationManager.GetResource(LocalizationResources.Collection_Mods.MergeCollection.Basic.Overlay_Writing_Files);
}
var overlayProgress = Smart.Format(localizationManager.GetResource(LocalizationResources.Collection_Mods.MergeCollection.Overlay_Progress), new
{
PercentDone = s.Percentage.ToLocalizedPercentage(),
Count = s.Step + 1,
TotalCount = 3
});
TriggerOverlay(id, true, message, overlayProgress);
}).DisposeWith(disposables);
}
else
{
modCompressProgressHandler = modCompressMergeProgressHandler.Subscribe(s =>
{
string message;
if (s.Step == 1)
{
message = localizationManager.GetResource(LocalizationResources.Collection_Mods.MergeCollection.Compress.Overlay_Gathering_Mod_Info);
}
else
{
message = localizationManager.GetResource(LocalizationResources.Collection_Mods.MergeCollection.Compress.Overlay_Compressing_Files);
}
var overlayProgress = Smart.Format(localizationManager.GetResource(LocalizationResources.Collection_Mods.MergeCollection.Overlay_Progress), new
{
PercentDone = s.Percentage.ToLocalizedPercentage(),
Count = s.Step + 1,
TotalCount = 3
});
TriggerOverlay(id, true, message, overlayProgress);
}).DisposeWith(disposables);
}
}
public void Release <T>(T component)
{
IDisposable disposable = component as IDisposable;
disposable?.Dispose();
}
/// <summary>
/// Constructs a new SingleInstance object
/// </summary>
/// <param name="appname">The application name</param>
/// <param name="basefolder">The folder in which the control file structure is placed</param>
public SingleInstance(string appname, string basefolder)
{
if (!System.IO.Directory.Exists(basefolder))
{
System.IO.Directory.CreateDirectory(basefolder);
}
m_controldir = System.IO.Path.Combine(basefolder, CONTROL_DIR);
if (!System.IO.Directory.Exists(m_controldir))
{
System.IO.Directory.CreateDirectory(m_controldir);
}
m_lockfilename = System.IO.Path.Combine(m_controldir, CONTROL_FILE);
m_file = null;
System.IO.Stream temp_fs = null;
try
{
if (Library.Utility.Utility.IsClientLinux)
{
temp_fs = UnixSupport.File.OpenExclusive(m_lockfilename, System.IO.FileAccess.Write);
}
else
{
temp_fs = System.IO.File.Open(m_lockfilename, System.IO.FileMode.Create, System.IO.FileAccess.Write, System.IO.FileShare.None);
}
if (temp_fs != null)
{
System.IO.StreamWriter sw = new System.IO.StreamWriter(temp_fs);
sw.WriteLine(System.Diagnostics.Process.GetCurrentProcess().Id);
sw.Flush();
//Do not dispose sw as that would dispose the stream
m_file = temp_fs;
}
}
catch
{
if (temp_fs != null)
{
try { temp_fs.Dispose(); }
catch {}
}
}
//If we have write access
if (m_file != null)
{
m_filewatcher = new System.IO.FileSystemWatcher(m_controldir);
m_filewatcher.Created += new System.IO.FileSystemEventHandler(m_filewatcher_Created);
m_filewatcher.EnableRaisingEvents = true;
DateTime startup = System.IO.File.GetLastWriteTime(m_lockfilename);
//Clean up any files that were created before the app launched
foreach (string s in System.IO.Directory.GetFiles(m_controldir))
{
if (s != m_lockfilename && System.IO.File.GetCreationTime(s) < startup)
{
try { System.IO.File.Delete(s); }
catch { }
}
}
}
else
{
//Wait for the initial process to signal that the filewatcher is activated
int retrycount = 5;
while (retrycount > 0 && new System.IO.FileInfo(m_lockfilename).Length == 0)
{
System.Threading.Thread.Sleep(500);
retrycount--;
}
//HACK: the unix file lock does not allow us to read the file length when the file is locked
if (new System.IO.FileInfo(m_lockfilename).Length == 0)
{
if (!Library.Utility.Utility.IsClientLinux)
{
throw new Exception("The file was locked, but had no data");
}
}
//Notify the other process that we have started
string filename = System.IO.Path.Combine(m_controldir, COMM_FILE_PREFIX + Guid.NewGuid().ToString());
//Write out the commandline arguments
string[] cmdargs = System.Environment.GetCommandLineArgs();
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(Library.Utility.Utility.IsClientLinux ? UnixSupport.File.OpenExclusive(filename, System.IO.FileAccess.Write) : new System.IO.FileStream(filename, System.IO.FileMode.CreateNew, System.IO.FileAccess.Write, System.IO.FileShare.None)))
for (int i = 1; i < cmdargs.Length; i++) //Skip the first, as that is the filename
{
sw.WriteLine(cmdargs[i]);
}
//Wait for the other process to delete the file, indicating that it is processed
retrycount = 5;
while (retrycount > 0 && System.IO.File.Exists(filename))
{
System.Threading.Thread.Sleep(500);
retrycount--;
}
//This may happen if the other process is closing as we write the command
if (System.IO.File.Exists(filename))
{
//Try to clean up, so the other process does not spuriously show this
try { System.IO.File.Delete(filename); }
catch { }
throw new Exception("The lock file was locked, but the locking process did not respond to the start command");
}
}
}
public FakedClass(IDisposable someInterface)
{
ParameterListLengthsForAttemptedConstructors.Add(1);
}
public void Add(IDisposable instance)
{
disposables.Add(new WeakReference(instance));
}
public override void MyTestInitialize()
{
base.MyTestInitialize();
m_PresenterTransaction = PresenterFactory.BeginSharedPresenterTransaction(m_Container, new BaseForm());
}
void SetKeepaliveTimer()
{
timerHandle?.Dispose();
timerHandle = Observable.Timer(DateTimeOffset.Now.AddMilliseconds(keepAliveTimeout))
.Subscribe(CheckKeepAlive);
}
public Cast(IObserver <TResult> observer, IDisposable cancel)
: base(observer, cancel)
{
}
public void StartServer()
{
_webServer = Microsoft.Owin.Hosting.WebApp.Start <Startup>(_url);
_looper.Start();
_dataMeterStateLooper.Start();
}
protected override IDisposable SubscribeCore(IObserver <TResult> observer, IDisposable cancel)
{
return(source.Subscribe(new Cast(observer, cancel)));
}
internal void AddDisposable(IDisposable disposable)
{
_Disposables.Add(disposable);
}
