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

 private static Yield Create_Helper(Plug dekiApi, int relto, string reltopath, IPackageReader packager, Result<ImportManager> result) {
     Result<XDoc> manifestResult;
     yield return manifestResult = packager.ReadManifest(new Result<XDoc>());
     Result<Importer> importerResult;
     if(string.IsNullOrEmpty(reltopath)) {
         yield return importerResult = Importer.CreateAsync(dekiApi, manifestResult.Value, relto, new Result<Importer>());
     } else {
         yield return importerResult = Importer.CreateAsync(dekiApi, manifestResult.Value, reltopath, new Result<Importer>());
     }
     result.Return(new ImportManager(importerResult.Value, packager));
     yield break;
 }

        internal static XDoc ExecuteScript(Plug env, DreamHeaders headers, XDoc script) {

            // execute script commands
            XDoc reply = new XDoc("results");
            string ID = script["@ID"].Contents;
            if(!string.IsNullOrEmpty(ID)) {
                reply.Attr("ID", ID);
            }
            foreach(XDoc cmd in script.Elements) {
                reply.Add(ExecuteCommand(env, headers, cmd));
            }
            return reply;
        }

 public void GlobalInit() {
     _adminPlug = Utils.BuildPlugForAdmin();
     _log.DebugFormat("admin plug: {0}", _adminPlug.Uri.ToString());
     _userId = null;
     string subscriber = null;
     UserUtils.CreateRandomContributor(_adminPlug, out _userId, out subscriber);
     _log.DebugFormat("created contributor {0} ({1})", subscriber, _userId);
     _pageSubscriberPlug = Utils.BuildPlugForUser(subscriber);
     _log.DebugFormat("subscriber plug: {0}", _pageSubscriberPlug.Uri.ToString());
     _pageSub = _pageSubscriberPlug.At("pagesubservice");
     DreamMessage response = PageUtils.CreateRandomPage(_adminPlug);
     Assert.IsTrue(response.IsSuccessful);
 }

        public static DreamMessage UploadFile(Plug p, string pageid, string description, out string fileid, string filename)
        {
            DreamMessage msg = DreamMessage.FromFile(filename);
            filename = XUri.DoubleEncode(System.IO.Path.GetFileName(filename));
            if (string.IsNullOrEmpty(description))
                msg = p.At("pages", pageid, "files", "=" + filename).Put(msg);
            else
                msg = p.At("pages", pageid, "files", "=" + filename).With("description", description).Put(msg);
            Assert.AreEqual(DreamStatus.Ok, msg.Status);
            fileid = msg.ToDocument()["@id"].AsText;
            Assert.IsFalse(string.IsNullOrEmpty(fileid));

            return msg;
        }

        //--- Constructors ---
        public RemoteInstanceManager(DekiWikiService dekiService, TaskTimerFactory timerFactory, XUri directoryUri, string tempPath) : base(dekiService, timerFactory) {

            // validate temp folder
            _tempPath = tempPath;
            if(!Directory.Exists(_tempPath)) {
                throw new ArgumentException("temp folder does not exist", "tempPath");
            }

            // check remote directory
            _directory = Plug.New(directoryUri);
            var testMsg = _directory.GetAsync().Wait();
            if(!testMsg.IsSuccessful) {
                _log.WarnFormat("Error validating remote deki portal service at '{0}'", directoryUri);
            }
        }