public static async Task <Screenshot> GetAppScreenshotAsync(Guid appGuid, AppScreenshotType screenshotType, AppScreenshotSize screenshotSize, int screenshotIndex) { //var rootFilter = new HttpBaseProtocolFilter(); //rootFilter.CacheControl.ReadBehavior = Windows.Web.Http.Filters.HttpCacheReadBehavior.MostRecent; //rootFilter.CacheControl.WriteBehavior = Windows.Web.Http.Filters.HttpCacheWriteBehavior.NoCache; var client = new HttpClient(); client.DefaultRequestHeaders.Add("appGuid", appGuid.ToString()); client.DefaultRequestHeaders.Add("screenshotType", screenshotType.ToString()); client.DefaultRequestHeaders.Add("screenshotSize", screenshotSize.ToString()); client.DefaultRequestHeaders.Add("screenshotIndex", screenshotIndex.ToString()); var response = await client.GetAsync(ServerUri.GetScreenshotDownloadUri(appGuid, screenshotIndex, (ScreenshotType)screenshotType, (ScreenshotSize)screenshotSize)); var buffer = await response.Content.ReadAsBufferAsync().AsTask(); var image = await buffer.ToArray().ConvertToBitmapImageAsync(); return(new Screenshot() { AppGuid = appGuid, OriginalImage = screenshotSize == AppScreenshotSize.Original ? image : null, ThumbnailImage = screenshotSize == AppScreenshotSize.Thumbnail ? image : null, Index = screenshotIndex }); }
public async Task StartDownloadAsync(AppDownloadItem appDownloadItem) { await InitializeAsync(); if (FindAppInCurrentDownloads(appDownloadItem.AppGuid) != null) { return; } // Start Download CurrentDownloads.Add(appDownloadItem); appDownloadItem.StorageFile = await CurrentApplication.AppDownloadFolder.CreateFileAsync( $"{appDownloadItem.AppGuid}.pstl", CreationCollisionOption.ReplaceExisting); var downloadOperation = await _downloader.StartDownloadAsync( ServerUri.GetAppDownloadUri(appDownloadItem.AppGuid), appDownloadItem.StorageFile); appDownloadItem.StartDate = DateTime.Now; appDownloadItem.DownloadGuid = downloadOperation.Guid; appDownloadItem.Tag = downloadOperation; // update collections _downloadsHistory.Add(appDownloadItem); await SaveDownloadsHistoryToFileAsync(); }
public override int GetHashCode() { int hash = 1; if (ForceUpdate != false) { hash ^= ForceUpdate.GetHashCode(); } if (ServerUri.Length != 0) { hash ^= ServerUri.GetHashCode(); } if (ActualEnvId.Length != 0) { hash ^= ActualEnvId.GetHashCode(); } if (ManifestVersion.Length != 0) { hash ^= ManifestVersion.GetHashCode(); } if (qualityLevel_ != null) { hash ^= QualityLevel.GetHashCode(); } if (ForceUpdateUrl.Length != 0) { hash ^= ForceUpdateUrl.GetHashCode(); } if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } return(hash); }
public void Should_allow_multiple_connections() { var requests = new List <HttpWebRequest>(); Stopwatch connectionTimer = Stopwatch.StartNew(); int expected = 100; for (int i = 0; i < expected; i++) { var webRequest = (HttpWebRequest)WebRequest.Create(ServerUri.AppendPath("Services/MyService")); webRequest.Method = "POST"; using (Stream reque = webRequest.GetRequestStream()) { byte[] buffer = Encoding.UTF8.GetBytes("Hello"); reque.Write(buffer, 0, buffer.Length); } requests.Add(webRequest); } connectionTimer.Stop(); Trace.WriteLine("Established {0} connections in {0}ms".FormatWith(expected, connectionTimer.ElapsedMilliseconds)); requests.ForEach(request => { try { using (WebResponse webResponse = request.GetResponse()) { using (Stream responseStream = webResponse.GetResponseStream()) { string response = responseStream.ReadToEndAsText(); Trace.WriteLine(response); } webResponse.Close(); } } catch (WebException ex) { using (WebResponse response = ex.Response) { var httpResponse = (HttpWebResponse)response; Trace.WriteLine("HttpStatusCode: " + httpResponse.StatusCode); using (Stream data = response.GetResponseStream()) { string r = data.ReadToEndAsText(); Trace.WriteLine(r); } } } }); requests.Clear(); }
private Native.SyncConfiguration ToNative() { return(new Native.SyncConfiguration { SyncUserHandle = User.Handle, Url = ServerUri.ToString(), client_validate_ssl = EnableSSLValidation }); }
public static async Task <BitmapImage> GetAppBackgroundImageAsync(Guid appGuid) { var client = new HttpClient(); var response = await client.GetAsync(ServerUri.GetAppBackgroundImageUri(appGuid)); var buffer = await response.Content.ReadAsBufferAsync().AsTask(); return(await buffer.ToArray().ConvertToBitmapImageAsync()); }
private IUserService CreateUserService() { string serviceUrl = ServerUri.GetUserWcfServiceUri().OriginalString; NetHttpBinding binding = new NetHttpBinding(); binding.MaxReceivedMessageSize = 500 * 1024; _channelFactory = new ChannelFactory <IUserService>(binding, new EndpointAddress(serviceUrl)); return(_channelFactory.CreateChannel()); }
public async Task AddPlayerStatsAsync(string uuid) { var stats = new PlayerStatModel($"{ServerUri.TrimEnd('/')}/{uuid.TrimStart('/').TrimEnd('/')}.json"); if (await stats.ReadStatsAsync()) { PlayerStats.Add(stats); } }
private void OnPermissionsUpdated(Uri updatedUrl, Permissions oldPermissions, Permissions newPermissions) { // updated URI matches protocol, hostname, and port, and if it has a path, that matches too if (updatedUrl.Scheme == ServerUri.Scheme && updatedUrl.Authority == ServerUri.Authority && (updatedUrl.AbsolutePath == "/" || updatedUrl.AbsolutePath == ServerUri.AbsolutePath) && _appState != AppState.Stopped) { Startup(ServerUri.ToString(), SessionId); } }
protected override void EstablishContext() { SubscriptionServiceUri = SubscriptionServiceUri.Replace("loopback", "msmq"); ClientControlUri = ClientControlUri.Replace("loopback", "msmq"); ServerControlUri = ServerControlUri.Replace("loopback", "msmq"); ClientUri = ClientUri.Replace("loopback", "msmq"); ServerUri = ServerUri.Replace("loopback", "msmq"); base.EstablishContext(); }
/// <summary>创建连接,单工连接或者双工连接,适用于高级的Channel</summary> public virtual RpcConnection CreateConnection(ServerUri serverUri, RpcConnectionMode mode) { if (mode == RpcConnectionMode.Simplex) { return(new RpcSimplexConnection(this, serverUri)); } else { throw new NotSupportedException(); } }
public void Connecting_to_a_socket_server() { _webRequest = (HttpWebRequest)WebRequest.Create(ServerUri.AppendPath("version")); try { _webResponse = (HttpWebResponse)_webRequest.GetResponse(); } catch (WebException ex) { _webResponse = (HttpWebResponse)ex.Response; } }
/// <summary> /// Returns true if this connection info has the same /// data field values (server URL, project, and team) /// as the other object. Ignores LastUsage /// </summary> /// <param name="other">The other object to compare</param> /// <returns>true iff data fields match (ignores LastUsage field)</returns> public bool DataEquals(ConnectionInfo other) { if (other == null) { return(false); } // crash was reported over watson. // make sure Project and Team are not null first. return(ServerUri != null && ServerUri.Equals(other.ServerUri) && Project != null && Project.Equals(other.Project) && Team != null && Team.Equals(other.Team)); }
private void SetUriModel() { ServerUri.TojsonFile(); FileStream fileStream = new FileStream(Jsonpath, FileMode.Open); StreamReader sw = new StreamReader(fileStream); var jsonvar = sw.ReadToEnd(); sw.Close(); sw.Dispose(); fileStream.Close(); fileStream.Dispose(); ServerUri = JsonConvert.DeserializeObject <ServerUriModel>(jsonvar); }
private Uri GetRequestUri(string query) { var uri = ServerUri.ToString(); if (!uri.EndsWith("?") && !uri.EndsWith("&")) { uri += "?"; } uri += "SERVICE=WMS&VERSION=" + Version + "&REQUEST=" + query; return(new Uri(uri.Replace(" ", "%20"))); }
/// <summary> /// 创建连接 /// </summary> /// <param name="serverUri"></param> /// <param name="mode">单工或是双工连接</param> /// <returns></returns> public override RpcConnection CreateConnection(ServerUri serverUri, RpcConnectionMode mode) { switch (mode) { case RpcConnectionMode.Simplex: return(new RpcTcpSimplexConnection(this, (TcpUri)serverUri, p_channelSettings.ConcurrentConnection)); case RpcConnectionMode.Duplex: return(new RpcTcpDuplexConnection(this, (TcpUri)serverUri)); default: throw new NotSupportedException(); } }
/// <summary> /// 创建一个Transaction /// </summary> /// <param name="uri"></param> /// <param name="request"></param> /// <returns></returns> /// <remarks>这个事务会建立在单工的Tcp连接上</remarks> public override RpcClientTransaction CreateTransaction(ServerUri uri, RpcRequest request) { RpcTcpSimplexConnection conn; lock (_syncRoot) { if (!_simplexConnections.TryGetValue(uri, out conn)) { conn = new RpcTcpSimplexConnection(this, (TcpUri)uri, p_channelSettings.ConcurrentConnection); conn.Disconnected += new Action <RpcConnection>(conn_Disconnected); _simplexConnections.Add(uri, conn); } } return(conn.CreateTransaction(request)); }
private Native.SyncConfiguration ToNative() { if (!string.IsNullOrEmpty(TrustedCAPath) && !File.Exists(TrustedCAPath)) { throw new FileNotFoundException($"{nameof(TrustedCAPath)} has been specified, but the file was not found.", TrustedCAPath); } return(new Native.SyncConfiguration { SyncUserHandle = User.Handle, Url = ServerUri.ToString(), client_validate_ssl = EnableSSLValidation, TrustedCAPath = TrustedCAPath }); }
internal override Realm CreateRealm(RealmSchema schema) { var configuration = new Realms.Native.Configuration { schema_version = SchemaVersion }; var syncConfiguration = new Native.SyncConfiguration { SyncUserHandle = User.Handle, Url = ServerUri.ToString() }; var srHandle = SharedRealmHandleExtensions.OpenWithSync(configuration, syncConfiguration, schema, EncryptionKey); return(new Realm(srHandle, this, schema)); }
public override int GetHashCode() { int hash = 1; if (serverUri_ != null) { hash ^= ServerUri.GetHashCode(); } if (PathPrefix.Length != 0) { hash ^= PathPrefix.GetHashCode(); } if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } return(hash); }
static void Main(string[] args) { try { WriteLine("Starting"); WriteLine("Please enter user name"); var userName = ReadLine(); WriteLine("Please enter password"); var password = ReadLine(); var uri = new ServerUri("todo"); uri.SetUser(userName, password); var actions = new GdmActions(uri); var modelUri = "model://CHMI_W_FLOW_FCT/EU.WATER_OUT.CHMI.BECHYNE.FCT"; WriteLine($"Getting model for {modelUri}"); var model = actions.GetModel(modelUri); var firstCuve = model.Curves.First(c => c.Name == "CURVE"); var firstOd = firstCuve.CurveDates.First(); var versions = firstOd.Versions.Select(v => $"{modelUri}/CURVE/{firstOd.OnDateAsString}/{v.Name}").ToArray(); WriteLine($"Found {versions.Length} ondates"); // One by one, slow but only for demo versions.ForEach(v => { WriteLine($"Getting data for {v}"); (double[] data, string fullRange) = actions.GetGenicData(v, "range://default"); WriteLine($"Found {data.Length} items for full range: {fullRange}"); }); } catch (Exception exp) { WriteLine(exp.Message); } WriteLine("Press any key to exit"); ReadKey(); }
internal override Realm CreateRealm(RealmSchema schema) { var configuration = new Realms.Native.Configuration { Path = DatabasePath, schema_version = SchemaVersion }; var syncConfiguration = new Native.SyncConfiguration { SyncUserHandle = User.Handle, Url = ServerUri.ToString(), client_validate_ssl = EnableSSLValidation, }; var srHandle = SharedRealmHandleExtensions.OpenWithSync(configuration, syncConfiguration, schema, EncryptionKey); return(new Realm(srHandle, this, schema)); }
public void MergeFrom(HttpService other) { if (other == null) { return; } if (other.serverUri_ != null) { if (serverUri_ == null) { serverUri_ = new global::Envoy.Api.V2.Core.HttpUri(); } ServerUri.MergeFrom(other.ServerUri); } if (other.PathPrefix.Length != 0) { PathPrefix = other.PathPrefix; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); }
private static void Branch_SetServerEnabled(XmlDocument doc, Object parameters) { ServerUri uri = (ServerUri)(parameters as Object[])[0]; bool blValue = (bool)(parameters as Object[])[1]; if (uri is ArcIMSServerUri) { SetArcIMSServerEnabled(doc, uri as ArcIMSServerUri, blValue); } else if (uri is DapServerUri) { SetDAPServerEnabled(doc, uri as DapServerUri, blValue); } else if (uri is WMSServerUri) { SetWMSServerEnabled(doc, uri as WMSServerUri, blValue); } else { throw new NotImplementedException(); } }
public RpcDuplexClient(ServerUri serverUri) { _serverUri = serverUri; _channel = RpcProxyFactory.GetChannel(serverUri); _timeout = _channel.Timeout; _connection = _channel.CreateConnection(serverUri, RpcConnectionMode.Duplex); _connection.Disconnected += new Action <RpcConnection>( (c) => { OnDisconnected(); } ); _connection.TransactionCreated += new Action <RpcConnection, RpcServerTransaction>( (c, tx) => { _dispatcher.ProcessTransaction(tx); } ); _dispatcher = new RpcServiceDispather("duplex"); }
internal static void SetFavourite(ServerUri oUri) { ExecuteUpdate(new UpdateDelegate(Branch_SetFavourite), oUri); }
internal static void RemoveServer(ServerUri oUri) { ExecuteUpdate(new UpdateDelegate(Branch_RemoveServer), oUri); }
internal static void SetServerEnabled(ServerUri oUri, bool blEnabled) { ExecuteUpdate(new UpdateDelegate(Branch_SetServerEnabled), new Object[] { oUri, blEnabled }); }
internal static bool ContainsServer(ServerUri oUri) { return(ExecuteQuery(new QueryDelegate(Branch_ContainsServer), oUri)); }
public bool IsUrl() { return(ServerUri.IsUrl()); }