public void ParseCookies_with_unquoted_values2() { List <DreamCookie> result = DreamCookie.ParseCookieHeader("__utma=134392366.2030730348.1275932450.1276553042.1276556836.19; __utmz=134392366.1276207881.9.3.utmcsr=developer.mindtouch.com|utmccn=(referral)|utmcmd=referral|utmcct=/User:arnec/bugs; _mkto_trk=id:954-WGP-507&token:_mch-mindtouch.com-1270756717014-83706; WRUID=0; __kti=1274382964652,http%3A%2F%2Fwww.mindtouch.com%2F,; __ktv=2f4-f02d-634b-51e2128b724d7c2; __qca=P0-2102347259-1274460371553; PHPSESSID=307e779182909ab37932b4dffe77c40a; __utmc=134392366; __kts=1274382964673,http%3A%2F%2Fwww.mindtouch.com%2F,; __ktt=631f-d0a2-648e-e0b128b724d7c2; authtoken=\"1_634121336269193470_4254e33b49bc1ee0a72c5716200e296b\"; __utmb=134392366.6.10.1276556836"); Assert.AreEqual(13, result.Count); Assert.AreEqual("__utma", result[0].Name); Assert.AreEqual("134392366.2030730348.1275932450.1276553042.1276556836.19", result[0].Value); Assert.AreEqual("__utmz", result[1].Name); Assert.AreEqual("134392366.1276207881.9.3.utmcsr=developer.mindtouch.com|utmccn=(referral)|utmcmd=referral|utmcct=/User:arnec/bugs", result[1].Value); Assert.AreEqual("_mkto_trk", result[2].Name); Assert.AreEqual("id:954-WGP-507&token:_mch-mindtouch.com-1270756717014-83706", result[2].Value); Assert.AreEqual("WRUID", result[3].Name); Assert.AreEqual("0", result[3].Value); Assert.AreEqual("__kti", result[4].Name); Assert.AreEqual("1274382964652,http%3A%2F%2Fwww.mindtouch.com%2F,", result[4].Value); Assert.AreEqual("__ktv", result[5].Name); Assert.AreEqual("2f4-f02d-634b-51e2128b724d7c2", result[5].Value); Assert.AreEqual("__qca", result[6].Name); Assert.AreEqual("P0-2102347259-1274460371553", result[6].Value); Assert.AreEqual("PHPSESSID", result[7].Name); Assert.AreEqual("307e779182909ab37932b4dffe77c40a", result[7].Value); Assert.AreEqual("__utmc", result[8].Name); Assert.AreEqual("134392366", result[8].Value); Assert.AreEqual("__kts", result[9].Name); Assert.AreEqual("1274382964673,http%3A%2F%2Fwww.mindtouch.com%2F,", result[9].Value); Assert.AreEqual("__ktt", result[10].Name); Assert.AreEqual("631f-d0a2-648e-e0b128b724d7c2", result[10].Value); Assert.AreEqual("authtoken", result[11].Name); Assert.AreEqual("1_634121336269193470_4254e33b49bc1ee0a72c5716200e296b", result[11].Value); Assert.AreEqual("__utmb", result[12].Name); Assert.AreEqual("134392366.6.10.1276556836", result[12].Value); }
//--- Constructors --- /// <summary> /// Create a new subscription set. /// </summary> /// <param name="owner">Owner uri.</param> /// <param name="version">Version serial number.</param> /// <param name="cookie">Pub sub location access cookie.</param> /// <param name="childSubscriptions">Subscriptions.</param> public PubSubSubscriptionSet(XUri owner, long version, DreamCookie cookie, params PubSubSubscription[] childSubscriptions) { Owner = owner; Version = version; Dictionary <string, PubSubSubscription> subs = new Dictionary <string, PubSubSubscription>(); foreach (PubSubSubscription sub in childSubscriptions) { foreach (XUri channel in sub.Channels) { if (channel.Scheme == "pubsub") { // pubsub scheme is for PubSubService internal use only, so it should never be aggregated continue; } XUri[] resources = (sub.Resources == null || sub.Resources.Length == 0) ? new XUri[] { null } : sub.Resources; foreach (XUri resource in resources) { PubSubSubscription combo; string key = channel + ":" + resource; subs.TryGetValue(key, out combo); subs[key] = PubSubSubscription.MergeForChannelAndResource(channel, resource, this, cookie, sub, combo); } } } Subscriptions = new PubSubSubscription[subs.Count]; subs.Values.CopyTo(Subscriptions, 0); MaxFailures = MAX_FAILURES; }
protected virtual Yield PutConfig(DreamContext context, DreamMessage request, Result <DreamMessage> response) { XDoc config = request.ToDocument(); if (config.Name != "config") { throw new DreamBadRequestException("bad document type"); } if (IsStarted) { throw new DreamBadRequestException("service must be stopped first"); } _timerFactory = TaskTimerFactory.Create(this); // configure service container var lifetimeScope = _env.CreateServiceLifetimeScope(this, (c, b) => PreInitializeLifetimeScope(c, b, config)); // call container-less start (which contains shared start logic) yield return(Coroutine.Invoke(Start, request.ToDocument(), new Result())); // call start with container for sub-classes that want to resolve instances at service start yield return(Coroutine.Invoke(Start, config, lifetimeScope, new Result())); response.Return(DreamMessage.Ok(new XDoc("service-info") .Start("private-key") .Add(DreamCookie.NewSetCookie("service-key", PrivateAccessKey, Self.Uri).AsSetCookieDocument) .End() .Start("internal-key") .Add(DreamCookie.NewSetCookie("service-key", InternalAccessKey, Self.Uri).AsSetCookieDocument) .End() )); }
public void Render_SetCookie_header_for_domainname_does_start_with_dot() { string header = DreamCookie.NewSetCookie("foo", "bar", new XUri("http://foo.com/x/y/z")).ToSetCookieHeader(); Assert.IsTrue(header.Contains("Path=/x/y/z"), "path is bad: " + header); Assert.IsTrue(header.Contains("Domain=.foo.com"), "domain is bad: " + header); }
public void Render_SetCookie_header_for_localhost_does_not_start_with_dot() { string header = DreamCookie.NewSetCookie("foo", "bar", new XUri("http://localhost/x/y/z")).ToSetCookieHeader(); Assert.IsTrue(header.Contains("Path=/x/y/z"), "path is bad: " + header); Assert.IsFalse(header.Contains("Domain"), "domain found: " + header); }
public DreamMessage SyncDreamCookies( [Cookie] DreamCookie x, [Cookie] string y ) { return(Response(new XDoc("r").Elem("x", x.Value).Elem("y", y))); }
public void SetCookie_to_header_and_back() { DreamCookie cookie1 = DreamCookie.NewSetCookie( "foo", "bar", new XUri("http://abc.com/path"), DateTime.Now.AddDays(1), true, "blah blah", new XUri("http://comment.com/blah")); string header = cookie1.ToSetCookieHeader(); List <DreamCookie> cookies = DreamCookie.ParseSetCookieHeader(header); Assert.AreEqual(1, cookies.Count); DreamCookie cookie2 = cookies[0]; Assert.AreEqual(cookie1.Comment, cookie2.Comment); Assert.AreEqual(cookie1.CommentUri, cookie2.CommentUri); Assert.AreEqual(cookie1.Domain, cookie2.Domain); Assert.AreEqual(cookie1.Expires, cookie2.Expires); Assert.AreEqual(cookie1.Expired, cookie2.Expired); Assert.AreEqual(cookie1.Name, cookie2.Name); Assert.AreEqual(cookie1.Path, cookie2.Path); Assert.AreEqual(cookie1.Secure, cookie2.Secure); Assert.AreEqual(cookie1.Uri, cookie2.Uri); Assert.AreEqual(cookie1.Value, cookie2.Value); }
/// <summary> /// Perform shutdown cleanup of a service instance. /// </summary> /// <remarks> /// Should not be manually invoked. /// </remarks> /// <param name="result">Synchronization handle for coroutine invocation.</param> /// <returns>Iterator used by <see cref="Coroutine"/> execution environment.</returns> protected virtual Yield Stop(Result result) { // ungrant owner and parent, otherwise they end up with thousands of grants DreamCookie cookie = DreamCookie.NewSetCookie("service-key", string.Empty, Self.Uri, DateTime.UtcNow); // ignore if these operations fail since we're shutting down anyway yield return(Env.At("@grants").Post(DreamMessage.Ok(cookie.AsSetCookieDocument), new Result <DreamMessage>(TimeSpan.MaxValue)).CatchAndLog(_log)); if (Owner != null) { yield return(Owner.At("@grants").Post(DreamMessage.Ok(cookie.AsSetCookieDocument), new Result <DreamMessage>(TimeSpan.MaxValue)).CatchAndLog(_log)); } _log.Debug("Stop"); // reset fields _self = null; _owner = null; _storage = null; _config = XDoc.Empty; _apikey = null; _cookies.Clear(); _license = null; _env.DisposeServiceContainer(this); // we're done result.Return(); }
public override DreamAccess DetermineAccess(DreamContext context, DreamMessage request) { if (context.Feature.Signature.StartsWith("subscribers/")) { string id = context.GetParam("id", null); PubSubSubscriptionSet set = _dispatcher[id]; if (set != null) { string accessKey = context.GetParam("access-key", null); if (string.IsNullOrEmpty(accessKey)) { DreamCookie cookie = DreamCookie.GetCookie(request.Cookies, "access-key"); if (cookie != null) { accessKey = cookie.Value; } } if (StringUtil.EqualsInvariant(set.AccessKey, accessKey)) { return(DreamAccess.Private); } _log.DebugFormat("no matching access-key in query or cookie for location '{0}'", id); } else { _log.DebugFormat("no subscription set for location '{0}'", id); } } return(base.DetermineAccess(context, request)); }
/// <summary> /// Add a header. /// </summary> /// <param name="name">Header name.</param> /// <param name="value">Header value.</param> /// <returns>Current instance.</returns> public DreamHeaders Add(string name, string value) { if (name == COOKIE) { Cookies.AddRange(DreamCookie.ParseCookieHeader(value)); } else if (name == SET_COOKIE) { Cookies.AddRange(DreamCookie.ParseSetCookieHeader(value)); } else { Entry entry; if (_headers.TryGetValue(name, out entry)) { entry.Last.Next = new Entry(value); } else { // create a new entry _headers[name] = new Entry(value); } } return(this); }
private DreamMessage BuildSetAuthTokenResponse(string authToken, XUri redirect) { DreamMessage responseMsg; if (redirect == null) { responseMsg = DreamMessage.Ok(MimeType.TEXT_UTF8, authToken); } else { responseMsg = DreamMessage.Redirect(redirect); } // set expiration time, if one is provided DateTime expires = DateTime.MinValue; // Default to no expiration attribute (session cookie) TimeSpan authCookieExpirationTime = DekiContext.Current.Instance.AuthCookieExpirationTime; if (authCookieExpirationTime.TotalSeconds > 0) { expires = DateTime.UtcNow.Add(authCookieExpirationTime); } // add 'Set-Cookie' header responseMsg.Cookies.Add(DreamCookie.NewSetCookie(AUTHTOKEN_COOKIENAME, authToken, Self.Uri.AsPublicUri().WithoutPathQueryFragment(), expires)); // add 'P3P' header for IE responseMsg.Headers["P3P"] = "CP=\"IDC DSP COR ADM DEVi TAIi PSA PSD IVAi IVDi CONi HIS OUR IND CNT\""; return(responseMsg); }
public void Parse_cookie_without_path_or_domain() { List <DreamCookie> cookies = DreamCookie.ParseCookieHeader("foo=\"bar\""); Assert.IsNull(cookies[0].Path); Assert.IsNull(cookies[0].Domain); }
//--- Constructors --- /// <summary> /// Create a new dispatcher. /// </summary> /// <param name="config">Configuration instance injected from pub sub service.</param> public Dispatcher(DispatcherConfig config) { _owner = config.ServiceUri.AsServerUri(); _serviceKeySetCookie = config.ServiceAccessCookie; _combinedSet = new PubSubSubscriptionSet(_owner, 0, _serviceKeySetCookie); _dispatchQueue = new ProcessingQueue <DispatcherEvent>(DispatchFromQueue, 10); }
/// <summary> /// Add a range of headers. /// </summary> /// <param name="headers">Key value pair collection</param> /// <returns>Current instance.</returns> public DreamHeaders AddRange(IEnumerable <KeyValuePair <string, string> > headers) { if (headers != null) { foreach (var header in headers) { if (header.Key.EqualsInvariantIgnoreCase(COOKIE)) { if (!string.IsNullOrEmpty(header.Value)) { Cookies.AddRange(DreamCookie.ParseCookieHeader(header.Value)); } } else if (header.Key.EqualsInvariantIgnoreCase(SET_COOKIE)) { if (!string.IsNullOrEmpty(header.Value)) { Cookies.AddRange(DreamCookie.ParseSetCookieHeader(header.Value)); } } else if (header.Key.EqualsInvariantIgnoreCase(ETAG) || header.Key.EndsWithInvariantIgnoreCase(IF_NONE_MATCH)) { // Note: Since ETAG may be quoted, strip quotes from ETAG and its counter-part If-None-Match var value = header.Value; if (!string.IsNullOrEmpty(value)) { if ((value.StartsWith("\"") && value.EndsWith("\"")) || (value.StartsWith("'") && value.EndsWith("'"))) { value = value.Substring(1, value.Length - 2); } _headers[header.Key] = new Entry(value); } } else { // Note (arnec): assume that there are no multi-value values Entry existing; // find existing entry if (_headers.TryGetValue(header.Key, out existing)) { existing = existing.Last; } // add new entries if (existing == null) { existing = new Entry(header.Value); _headers[header.Key] = existing; } else { existing.Next = new Entry(header.Value); } } } } return(this); }
private Yield CreateService_Helper(string path, string sid, XDoc config, Result <Plug> result) { if (path == null) { throw new ArgumentNullException("path"); } if (sid == null) { throw new ArgumentNullException("sid"); } if (config == null) { throw new ArgumentNullException("config"); } // check if we have a licensekey for the requested SID string serviceLicense = TryGetServiceLicense(XUri.TryParse(sid) ?? XUri.Localhost); // add parameters to config document Plug plug = Self.AtPath(path); config.Root .Elem("path", plug.Uri.Path) .Elem("sid", sid) // add 'owner' and make sure we keep it in 'local://' format .Elem("uri.owner", Self.Uri.ToString()) // add 'internal' access key .Add(DreamCookie.NewSetCookie("service-key", InternalAccessKey, Self.Uri).AsSetCookieDocument) // add optional 'service-license' token .Elem("service-license", serviceLicense); // inject parent apikey if apikey not defined if (config["apikey"].IsEmpty) { config.Root.Elem("apikey", _apikey); } // post to host to create service Result <DreamMessage> res; yield return(res = Env.At("services").Post(config, new Result <DreamMessage>(TimeSpan.MaxValue))); if (!res.Value.IsSuccessful) { if (res.Value.HasDocument) { string message = res.Value.ToDocument()[".//message"].AsText.IfNullOrEmpty("unknown error"); throw new DreamResponseException(res.Value, string.Format("unable to initialize service ({0})", message)); } else { throw new DreamResponseException(res.Value, string.Format("unable to initialize service ({0})", res.Value.ToText())); } } result.Return(plug); yield break; }
internal Yield PostGrant(DreamContext context, DreamMessage request, Result <DreamMessage> response) { lock (Cookies) { Cookies.Update(DreamCookie.ParseAllSetCookieNodes(request.ToDocument()), null); } response.Return(DreamMessage.Ok()); yield break; }
public void ParseCookies2() { List <DreamCookie> cookies = DreamCookie.ParseCookieHeader("Customer=\"WILE_E_COYOTE\"; $Path=\"/acme\""); Assert.AreEqual(1, cookies.Count, "failed to parse cookies"); Assert.AreEqual("Customer", cookies[0].Name, "bad cookie name"); Assert.AreEqual("WILE_E_COYOTE", cookies[0].Value, "bad cookie value"); Assert.AreEqual("/acme", cookies[0].Path, "bad cookie path"); }
private DreamCookieJar GetJar(XDoc setCookieElement) { DreamCookieJar jar = new DreamCookieJar(); List <DreamCookie> collection = new List <DreamCookie>(); collection.Add(DreamCookie.ParseSetCookie(setCookieElement)); jar.Update(collection, null); return(jar); }
public void ParseBadCookie5() { var cookies = DreamCookie.ParseCookieHeader(" foo=\"bar\", hello=wo;;rld; authtoken=\"1234\" "); Assert.AreEqual(4, cookies.Count, "Failed to parse cookies, wrong number of resulting cookies"); Assert.AreEqual(cookies[0].Name, "foo", "bad cookie name"); Assert.AreEqual(cookies[0].Value, "bar", "bad cookie value"); Assert.AreEqual(cookies[3].Name, "authtoken", "bad cookie name"); Assert.AreEqual(cookies[3].Value, "1234", "bad cookie value"); }
public void Parse_2_cookies_separated_by_semicolon() { List <DreamCookie> cookies = DreamCookie.ParseCookieHeader("PHPSESSID=663e17bc2eaef4e355c6e6fe1bb86c04; authtoken=1_633644446772281250_c3dd88ad4539197ef12f3614e91fec8f"); Assert.AreEqual(2, cookies.Count); Assert.AreEqual("PHPSESSID", cookies[0].Name); Assert.AreEqual("663e17bc2eaef4e355c6e6fe1bb86c04", cookies[0].Value); Assert.AreEqual("authtoken", cookies[1].Name); Assert.AreEqual("1_633644446772281250_c3dd88ad4539197ef12f3614e91fec8f", cookies[1].Value); }
public void ParseBadCookie1() { var cookies = DreamCookie.ParseCookieHeader("foo=\"bar\"; [index.php]scayt_verLang=5; authtoken=\"1234\""); Assert.AreEqual(3, cookies.Count, "Failed to parse cookies, wrong number of resulting cookies"); Assert.AreEqual(cookies[0].Name, "foo", "bad cookie name"); Assert.AreEqual(cookies[0].Value, "bar", "bad cookie value"); Assert.AreEqual(cookies[2].Name, "authtoken", "bad cookie name"); Assert.AreEqual(cookies[2].Value, "1234", "bad cookie value"); }
public void Parse_5_cookies_separated_by_semicolon() { List <DreamCookie> cookies = DreamCookie.ParseCookieHeader("authtoken=\"3_633644459231333750_74b1192b1846f065523d01ac18c772c5\"; PHPSESSID=34c4b18a50a91dd99adb1ed1e6b570cb; __utma=14492279.2835659202033839600.1228849092.1228849092.1228849092.1; __utmc=14492279; __utmz=14492279.1228849092.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none)"); Assert.AreEqual(5, cookies.Count); Assert.AreEqual("authtoken", cookies[0].Name); Assert.AreEqual("3_633644459231333750_74b1192b1846f065523d01ac18c772c5", cookies[0].Value); Assert.AreEqual("PHPSESSID", cookies[1].Name); Assert.AreEqual("34c4b18a50a91dd99adb1ed1e6b570cb", cookies[1].Value); }
public void ParseBadCookie3() { var cookies = DreamCookie.ParseCookieHeader(" foo=\"bar\", lithiumLogin:successfactors=~2acHBr09HxytcqIXV~eVqhSr8s74VfDTjhQ8XU615EaYeGn-7OdDSN70BshVnsYG71yPbJvKPoZzHl05KP; authtoken=\"1234\" "); Assert.AreEqual(3, cookies.Count, "Failed to parse cookies, wrong number of resulting cookies"); Assert.AreEqual(cookies[0].Name, "foo", "bad cookie name"); Assert.AreEqual(cookies[0].Value, "bar", "bad cookie value"); Assert.AreEqual(cookies[2].Name, "authtoken", "bad cookie name"); Assert.AreEqual(cookies[2].Value, "1234", "bad cookie value"); }
public void GetCookie_with_no_path() { List <DreamCookie> cookies = new List <DreamCookie>(); cookies.Add(new DreamCookie("foo", "bar", null)); DreamCookie c = DreamCookie.GetCookie(cookies, "foo"); Assert.IsNotNull(c); Assert.AreEqual("bar", c.Value); }
//--- Methods --- protected override Yield Start(XDoc config, Result result) { yield return(Coroutine.Invoke(base.Start, config, new Result())); _varnish = Plug.New(Config["uri.varnish"].AsUri); _deki = Plug.New(Config["uri.deki"].AsUri); _apikey = Config["apikey"].AsText; _delayPurgeTimespan = TimeSpan.FromSeconds(config["varnish-purge-delay"].AsInt ?? 10); var dispatcher = new UpdateRecordDispatcher(OnQueueExpire); _updateDelayQueue = new UpdateDelayQueue(_delayPurgeTimespan, dispatcher); // set up subscription for pubsub XDoc subscriptionSet = new XDoc("subscription-set") .Elem("uri.owner", Self.Uri) .Start("subscription") .Add(DreamCookie.NewSetCookie("service-key", InternalAccessKey, Self.Uri).AsSetCookieDocument) .Elem("channel", "event://*/deki/pages/create") .Elem("channel", "event://*/deki/pages/move") .Elem("channel", "event://*/deki/pages/update") .Elem("channel", "event://*/deki/pages/delete") .Elem("channel", "event://*/deki/pages/revert") .Elem("channel", "event://*/deki/pages/createalias") .Elem("channel", "event://*/deki/pages/tags/update") .Elem("channel", "event://*/deki/pages/dependentschanged/comments/create") .Elem("channel", "event://*/deki/pages/dependentschanged/comments/update") .Elem("channel", "event://*/deki/pages/dependentschanged/comments/delete") .Elem("channel", "event://*/deki/pages/dependentschanged/files/create") .Elem("channel", "event://*/deki/pages/dependentschanged/files/update") .Elem("channel", "event://*/deki/pages/dependentschanged/files/delete") .Elem("channel", "event://*/deki/pages/dependentschanged/files/move") .Elem("channel", "event://*/deki/pages/dependentschanged/files/restore") .Elem("channel", "event://*/deki/files/create") .Elem("channel", "event://*/deki/files/update") .Elem("channel", "event://*/deki/files/delete") .Elem("channel", "event://*/deki/files/move") .Elem("channel", "event://*/deki/files/restore") .Start("recipient") .Attr("authtoken", _apikey) .Elem("uri", Self.Uri.At("queue")) .End() .End(); Result <DreamMessage> subscriptionResult; yield return(subscriptionResult = PubSub.At("subscribers").PostAsync(subscriptionSet)); string accessKey = subscriptionResult.Value.ToDocument()["access-key"].AsText; XUri location = subscriptionResult.Value.Headers.Location; Cookies.Update(DreamCookie.NewSetCookie("access-key", accessKey, location), null); _subscriptionLocation = location.AsLocalUri().WithoutQuery(); _log.DebugFormat("subscribed VarnishPurgeService for events at {0}", _subscriptionLocation); result.Return(); }
public void SetCookie_without_uri() { DreamCookie cookie = DreamCookie.NewSetCookie("foo", "bar", null); Assert.IsNull(cookie.Path); Assert.IsNull(cookie.Domain); string cookieHeader = cookie.ToSetCookieHeader(); Assert.IsFalse(cookieHeader.Contains("Path")); Assert.IsFalse(cookieHeader.Contains("Domain")); }
public void ParseCookies5() { List <DreamCookie> result = DreamCookie.ParseCookieHeader("Customer=WILE_E_COYOTE; $Path=\"/acme\", Part_Number=\"Rocket \\\"Launcher\\\" 0001\"; $Path=\"/acme\""); Assert.AreEqual(2, result.Count); Assert.AreEqual("Customer", result[0].Name); Assert.AreEqual("WILE_E_COYOTE", result[0].Value); Assert.AreEqual("/acme", result[0].Path); Assert.AreEqual("Part_Number", result[1].Name); Assert.AreEqual("Rocket \"Launcher\" 0001", result[1].Value); Assert.AreEqual("/acme", result[1].Path); }
public void TestCookie2() { Plug test = _host.At("test"); DreamMessage request = DreamMessage.Ok(); DreamCookie cookie = new DreamCookie("test-cookie", "test-value", null); request.Cookies.Add(cookie); DreamMessage response = test.Post(request); Assert.AreEqual(DreamStatus.Ok, response.Status); Assert.IsFalse(response.ToDocument()["body"].IsEmpty); Assert.AreEqual(cookie.ToString(), DreamCookie.ParseCookie(response.ToDocument()["headers/cookie"]).ToString()); }
public void ParseCookies7() { List <DreamCookie> cookies = new List <DreamCookie>(); cookies.Add(new DreamCookie("Customer", "WILE_E_COYOTE", new XUri("http://localhost/acme"))); string header = DreamCookie.RenderCookieHeader(cookies); cookies = DreamCookie.ParseCookieHeader(header); Assert.AreEqual(1, cookies.Count, "failed to parse cookies"); Assert.AreEqual("Customer", cookies[0].Name, "bad cookie name"); Assert.AreEqual("WILE_E_COYOTE", cookies[0].Value, "bad cookie value"); Assert.AreEqual("/acme", cookies[0].Path, "bad cookie path"); }
private Yield ProloguePrivateStorage(DreamContext context, DreamMessage request, Result <DreamMessage> response) { //check if this services is private if (_private) { DreamCookie cookie = DreamCookie.GetCookie(request.Cookies, "service-key"); if (cookie == null || cookie.Value != PrivateAccessKey) { throw new DreamForbiddenException("insufficient access privileges"); } } response.Return(request); yield break; }