C# Dream.Plug类代码示例

        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;
        }

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

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

        // --- 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()));
        }

 //--- 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 static DreamMessage CreateRandomPage(Plug p, out string id)
        {
            string path = null;
            string title = GenerateUniquePageName();

            return PageUtils.SavePage(p, string.Empty, title, Utils.GetSmallRandomText(), out id, out path);
        }

 //--- Constructors ---
 public LuceneResultFilter(Plug authPlug, int maxAuthItems, int minAuthItems) {
     if(authPlug == null) {
         throw new ArgumentNullException("authPlug");
     }
     _authPlug = authPlug;
     _maxAuthItems = maxAuthItems;
     _minAuthItems = minAuthItems;
 }

 //--- Constructors ---
 private DreamApplication(DreamApplicationConfiguration appConfig)
 {
     _appConfig = appConfig;
     _env = new DreamHostService();
     Initialize();
     RegisterDefaultRoute();
     _self = Plug.New(_env.Self.Uri.AtAbsolutePath("/"));
 }

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

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

 private string GetServiceIDBySID(Plug p, string sid) {
     DreamMessage msg = p.At("site", "services").With("limit","all").Get();
     foreach(XDoc service in msg.ToDocument()["service"]) {
         if(service["sid"].AsText == sid)
             return service["@id"].AsText;
     }
     return null;
 }

        public static DreamMessage UploadRandomFile(Plug p, string pageid, byte[] content, string description, out string fileid, out string filename)
        {
            filename = FileUtils.CreateRamdomFile(content);
            DreamMessage msg = UploadFile(p, pageid, description, out fileid, filename);
            filename = msg.ToDocument()["filename"].AsText;
            Assert.IsFalse(string.IsNullOrEmpty(filename));

            return msg;
        }

 //--- Constructors ---
 public DekiDispatcher(DispatcherConfig config, IPubSubDispatchQueueRepository repository)
     : base(config, repository) {
     _authtoken = config.ServiceConfig["authtoken"].AsText;
     var dekiUri = config.ServiceConfig["uri.deki"].AsUri;
     if(config.ServiceCookies != null) {
         _cookieJar.Update(config.ServiceCookies.Fetch(dekiUri), null);
     }
     _deki = Plug.New(dekiUri).WithCookieJar(_cookieJar);
 }

 private static Yield Create_Helper(Plug dekiApi, XDoc exports, int relto, string reltopath, IPackageWriter packager, Result<ExportManager> result) {
     Result<Exporter> exporterResult;
     if(string.IsNullOrEmpty(reltopath)) {
         yield return exporterResult = Exporter.CreateAsync(dekiApi, exports, relto, new Result<Exporter>());
     } else {
         yield return exporterResult = Exporter.CreateAsync(dekiApi, exports, reltopath, new Result<Exporter>());
     }
     result.Return(new ExportManager(exporterResult.Value, packager));
     yield break;
 }

 public PageChangeCache(Plug deki, Action<string, Action> cacheItemCallback) {
     if(deki == null) {
         throw new ArgumentNullException("deki");
     }
     if(cacheItemCallback == null) {
         throw new ArgumentNullException("cacheItemCallback");
     }
    _cacheItemCallback = cacheItemCallback;
     _deki = deki;
 }

 protected override Yield Start(XDoc config, Result result) {
     Result res;
     yield return res = Coroutine.Invoke(base.Start, config, new Result());
     res.Confirm();
     var fs = new Result<Plug>();
     CreateService("mount", "http://services.mindtouch.com/dream/draft/2006/11/mount", 
         new XDoc("config").Start("mount").Attr("to", "files").Value("%DreamHost%").End(), fs);
     joinMeTL();
     _fs = fs.Value;
     result.Return();
 }

        protected CouchBase(string connectionStringName)
        {
            ConnectionStringSettings connectionString = ConfigurationManager.ConnectionStrings[connectionStringName];
            if(connectionString == null)
                throw new ArgumentException("Invalid connection string name");

            CouchDbConnectionStringBuilder cs = new CouchDbConnectionStringBuilder(connectionString.ConnectionString);

            BasePlug = Plug.New(String.Format("{0}://{1}:{2}",cs.SslEnabled ? "https" : "http", cs.Host, cs.Port))
                .WithCredentials(cs.UserName,cs.Password);
        }