C# Dream.XUri类代码示例

        protected CouchBase(XUri aBaseUri, string aUserName = null, string aPassword = null)
        {
            if (aBaseUri == null)
                throw new ArgumentNullException("aBaseUri");

            BasePlug = Plug.New(aBaseUri).WithCredentials(aUserName, aPassword);
        }

 //--- Methods ---
 private void CallbackHandler(Plug plug, string verb, XUri uri, DreamMessage request, Result<DreamMessage> response) {
     if(uri.Segments.Length == 0) {
         response.Return(DreamMessage.Ok());
         return;
     }
     var segments = uri.Segments;
     var wikiId = segments[0];
     if(wikiId.StartsWith("=")) {
         var id = (HostLookupOverride == null) ? DefaultWikiId : HostLookupOverride(wikiId.Substring(1));
         response.Return(DreamMessage.Ok(new XDoc("wiki").Attr("id", id)));
         return;
     }
     if(segments.Length == 2 && segments[1] == "license") {
         XDoc license;
         if(LicenseOverride == null) {
             _log.Debug("returning license from disk");
             license = XDocFactory.LoadFrom(Utils.Settings.LicensePath, MimeType.TEXT_XML);
         } else {
             _log.Debug("returning license from override callback");
             license = LicenseOverride(wikiId);
         }
         response.Return(DreamMessage.Ok(license));
         return;
     }
     var config = (ConfigOverride == null) ? DefaultConfig : ConfigOverride(wikiId);
     response.Return(DreamMessage.Ok(config));
 }

        public Yield Invoke(Plug plug, string verb, XUri uri, DreamMessage request, Result<DreamMessage> response)
        {
            // NOTE (steveb): we convert 'xri://@name/path?params' into 'http://xri.net/@name/path?params'

            // prepend segments with authority
            List<string> segments = new List<string>();
            segments.Add(uri.Authority);
            if(uri.Segments != null) {
                segments.AddRange(uri.Segments);
            }

            // build new plug
            List<PlugHandler> preHandlers = (plug.PreHandlers != null) ? new List<PlugHandler>(plug.PreHandlers) : null;
            List<PlugHandler> postHandlers = (plug.PostHandlers != null) ? new List<PlugHandler>(plug.PostHandlers) : null;
            Plug xri = new Plug(new XUri("http", null, null, "xri.net", 80, segments.ToArray(), uri.TrailingSlash, uri.Params, uri.Fragment), plug.Timeout, request.Headers, preHandlers, postHandlers, plug.Credentials, plug.CookieJar, plug.MaxAutoRedirects);

            // add 'Accept' header for 'application/xrds+xml' mime-type
            if((xri.Headers == null) || (xri.Headers.Accept == null)) {
                xri = xri.WithHeader(DreamHeaders.ACCEPT, MimeType.RenderAcceptHeader(MimeType.XRDS));
            }

            // BUGBUGBUG (steveb): this will probably fail in some cases since we may exit this coroutine before the call has completed!

            xri.InvokeEx(verb, request, response);
            yield break;
        }

        public void Exporter_hits_export_feature_on_creation_using_reltopath() {

            // Arrange
            XUri dekiApiUri = new XUri("http://mock/@api/deki");
            XDoc exportDocument = new XDoc("export")
                .Start("page")
                    .Attr("path", "/")
                    .Attr("recursive", "true")
                    .Attr("exclude", "all")
                .End();
            XDoc exportResponse = new XDoc("export")
                .Start("requests")
                .End()
                .Start("manifest")
                    .Elem("justanode")
                .End();
            AutoMockPlug mock = MockPlug.Register(dekiApiUri);
            mock.Expect("POST", dekiApiUri.At("site", "export").With("reltopath", "/foo/bar"), exportDocument, DreamMessage.Ok(exportResponse));

            // Act
            Exporter exporter = Exporter.CreateAsync(Plug.New(dekiApiUri), exportDocument, "/foo/bar", new Result<Exporter>()).Wait();

            //Assert
            Assert.IsTrue(mock.WaitAndVerify(TimeSpan.FromSeconds(1)));
            Assert.AreEqual(exportResponse["manifest"], exporter.Manifest);
        }

        public static string GetUrlLocalUri(XUri confBaseUri, string url, bool includeQuery, bool decode) {
            if(string.IsNullOrEmpty(url)) {
                return null;
            }

            if(url.StartsWithInvariantIgnoreCase(confBaseUri.ToString())) {
                
                //Remove the wiki path prefix (everything before display generally)
                url = confBaseUri.SchemeHostPort + url.Substring(confBaseUri.ToString().Length);
            }

            XUri uri = XUri.TryParse(url);
            
            if(uri == null) {
                return null;
            }
            string ret = uri.Path;
            if(decode) {
                ret = XUri.Decode(ret);
            }

            if(includeQuery && !string.IsNullOrEmpty(uri.QueryFragment)) {
                ret += uri.QueryFragment;
            }
            return ret;
        }

 public AwsEndpoint(string locationConstraint, string s3Uri, string sqsUri, string name)
 {
     S3Uri = new XUri(s3Uri);
     SqsUri = new XUri(sqsUri);
     LocationConstraint = locationConstraint;
     Name = name;
 }

        // --- Constructors ---
        public RemoteInstanceManager(DekiWikiService dekiService, XUri directoryUri) : base(dekiService) {
            _directory = Plug.New(directoryUri);

            DreamMessage testMsg = _directory.GetAsync().Wait();
            if (!testMsg.IsSuccessful)
                throw new DreamInternalErrorException(string.Format("Error validating remote deki portal service at '{0}'", directoryUri.ToString()));
        }

        //--- Class Methods ---
        public void RequestLog_Insert(XUri requestUri, string requestVerb, string requestHostHeader, string origin, string serviceHost, string serviceFeature, DreamStatus responseStatus, string username, uint executionTime, string response) {
            string host = requestUri.HostPort;
            if( !host.Contains(":"))
                host = host + ":80";

            //Schema for request log in "trunk/product/deki/web/maintenance/apirequestlog.sql"
            Catalog.NewQuery(@" /* RequestLog_Insert */
insert delayed into requestlog (
 	`rl_requesthost`, `rl_requesthostheader`, `rl_requestpath`, `rl_requestparams`, `rl_requestverb`, 
 	`rl_dekiuser`, `rl_origin`, `rl_servicehost`, `rl_servicefeature`, `rl_responsestatus`, `rl_executiontime`, 
 	`rl_response`
 ) values (
 	?REQUESTHOST, ?REQUESTHOSTHEADER, ?REQUESTPATH, ?REQUESTPARAMS, ?REQUESTVERB, 
 	?DEKIUSER, ?ORIGIN, ?SERVICEHOST, ?SERVICEFEATURE, ?RESPONSESTATUS, ?EXECUTIONTIME, 
 	?RESPONSE
 );")
                .With("REQUESTHOST", host)
                .With("REQUESTHOSTHEADER", requestHostHeader)
                .With("REQUESTPATH", requestUri.Path)
                .With("REQUESTPARAMS", requestUri.Query)
                .With("REQUESTVERB", requestVerb)
                .With("DEKIUSER", username)
                .With("ORIGIN", origin == null ? String.Empty : origin.ToLowerInvariant())
                .With("SERVICEHOST", serviceHost)
                .With("SERVICEFEATURE", serviceFeature)
                .With("RESPONSESTATUS", (int)responseStatus)
                .With("EXECUTIONTIME", executionTime)
                .With("RESPONSE", response)
                .Execute();
        }

 public void RegisterFunction(string functionName, MethodInfo method, DekiScriptNativeInvocationTarget.Parameter[] parameters) {
     var target = new DekiScriptNativeInvocationTarget(null, method, parameters.ToArray());
     var function = new DekiScriptInvocationTargetDescriptor(target.Access, false, false, functionName, target.Parameters, target.ReturnType, "", "", target);
     var functionPointer = new XUri("native:///").At(function.SystemName);
     Functions[functionPointer] = function;
     _funcMap[functionName] = functionPointer;
 }

        protected CouchBase(XUri baseUri, string username = null, 
      string password = null)
        {
            if (baseUri == null)
            throw new ArgumentNullException("baseUri");

              BasePlug = Plug.New(baseUri).WithCredentials(username, password);
        }

        public void ExportManager_chains_exporter_to_packager() {

            // Arrange
            XUri dekiApiUri = new XUri("http://mock/@api/deki");
            XDoc exportDocument = new XDoc("export");
            XUri item1Uri = dekiApiUri.At("foo", "bar", "abc");
            XDoc item1Doc = new XDoc("item1");
            XUri item2Uri = dekiApiUri.At("foo", "bar", "def");
            XDoc item2Doc = new XDoc("item2");
            XDoc exportResponse = new XDoc("export")
                .Start("requests")
                    .Start("request")
                        .Attr("method", "GET")
                        .Attr("dataid", "abc")
                        .Attr("href", item1Uri)
                        .Start("header").Attr("name", "h_1").Attr("value", "v_1").End()
                        .Start("header").Attr("name", "h_2").Attr("value", "v_2").End()
                    .End()
                    .Start("request")
                        .Attr("method", "GET")
                        .Attr("dataid", "def")
                        .Attr("href", item2Uri)
                    .End()
                .End()
                .Start("manifest")
                    .Start("foo").Attr("dataid", "abc").End()
                    .Start("bar").Attr("dataid", "def").End()
                .End();
            AutoMockPlug mock = MockPlug.Register(dekiApiUri);
            mock.Expect().Verb("POST").Uri(dekiApiUri.At("site", "export").With("relto", "0")).RequestDocument(exportDocument).Response(DreamMessage.Ok(exportResponse));
            mock.Expect().Verb("GET").Uri(item1Uri).RequestHeader("h_1", "v_1").RequestHeader("h_2", "v_2").Response(DreamMessage.Ok(item1Doc));
            mock.Expect().Verb("GET").Uri(item2Uri).Response(DreamMessage.Ok(item2Doc));
            var writes = new List<string>();
            var mockPackageWriter = new Mock<IPackageWriter>();
            mockPackageWriter.Setup(x => x.WriteDataAsync(It.IsAny<ExportItem>(), It.IsAny<Result>()))
                .Returns(() => new Result().WithReturn())
                .Callback((ExportItem item, Result result) => writes.Add(item.DataId))
                .AtMost(2)
                .Verifiable();
            mockPackageWriter.Setup(x => x.WriteManifest(It.IsAny<XDoc>(), It.IsAny<Result>()))
                .Returns(() => new Result().WithReturn())
                .AtMostOnce()
                .Verifiable();

            // Act
            ExportManager manager = ExportManager.CreateAsync(Plug.New(dekiApiUri), exportDocument, 0, mockPackageWriter.Object, new Result<ExportManager>()).Wait();
            manager.ExportAsync(new Result()).Wait();

            // Assert
            Assert.IsTrue(mock.WaitAndVerify(TimeSpan.FromSeconds(1)), mock.VerificationFailure);
            Assert.AreEqual(2, manager.TotalItems);
            Assert.AreEqual(2, manager.CompletedItems);
            Assert.AreEqual(new[] { "abc", "def" }, writes.ToArray());
            mockPackageWriter.Verify(x => x.Dispose(), Times.Once());
            mockPackageWriter.VerifyAll();
        }

 //--- Methods ---
 public int GetScoreWithNormalizedUri(XUri uri, out XUri normalized)
 {
     normalized = uri;
     switch(uri.Scheme) {
     case "resource":
         return Plug.BASE_ENDPOINT_SCORE;
     default:
         return 0;
     }
 }

 //--- Methods ---
 public int GetScoreWithNormalizedUri(XUri uri, out XUri normalized)
 {
     normalized = uri;
     switch(uri.Scheme) {
     case "xri":
         return 1;
     default:
         return 0;
     }
 }

 //--- Interface Methods ---
 int IPlugEndpoint.GetScoreWithNormalizedUri(XUri uri, out XUri normalized)
 {
     XDoc doc;
     normalized = uri;
     lock(_map) {
         if(!_map.TryGetValue(uri, out doc)) {
             return 0;
         }
     }
     return uri.MaxSimilarity;
 }

 //--- Class Methods ---
 /// <summary>
 /// Add a document for a uri.
 /// </summary>
 /// <param name="uri">Uri to intercept.</param>
 /// <param name="doc">Document to return for interception.</param>
 public static void Add(XUri uri, XDoc doc)
 {
     if(uri == null) {
         throw new ArgumentException("uri");
     }
     if(doc == null) {
         throw new ArgumentException("doc");
     }
     lock(_map) {
         _map[uri] = doc;
     }
 }