public IAsyncEnumerable <SoftwareIdentity> InstallPackage(SoftwareIdentity softwareIdentity, IRequestObject requestObject)
{
if (requestObject == null)
{
throw new ArgumentNullException("requestObject");
}
if (softwareIdentity == null)
{
throw new ArgumentNullException("softwareIdentity");
}
var hostApi = requestObject.As <IHostApi>();
// if the provider didn't say this was trusted, we should ask the user if it's ok.
if (!softwareIdentity.FromTrustedSource)
{
try {
if (!hostApi.ShouldContinueWithUntrustedPackageSource(softwareIdentity.Name, softwareIdentity.Source))
{
hostApi.Warning(hostApi.FormatMessageString(Constants.Messages.UserDeclinedUntrustedPackageInstall, softwareIdentity.Name));
return(new EmptyAsyncEnumerable <SoftwareIdentity>());
}
} catch {
return(new EmptyAsyncEnumerable <SoftwareIdentity>());
}
}
return(new SoftwareIdentityRequestObject(this, requestObject.As <IHostApi>(), request => Provider.InstallPackage(softwareIdentity.FastPackageReference, request), Constants.PackageStatus.Installed));
}
public void GetDynamicOptions(string category, IRequestObject requestObject)
{
if (requestObject == null)
{
throw new ArgumentNullException("requestObject");
}
using (var request = requestObject.As <BootstrapRequest>()) {
try {
request.Debug("Calling 'Bootstrap::GetDynamicOptions ({0})'", category);
switch ((category ?? string.Empty).ToLowerInvariant())
{
case "package":
// request.YieldDynamicOption( "ForceCheck", OptionType.Switch, false);
break;
case "source":
break;
case "install":
request.YieldDynamicOption("DestinationPath", OptionType.Folder.ToString(), true);
break;
}
} catch {
// this makes it ignore new OptionCategories that it doesn't know about.
}
}
}
/// <summary>
/// Returns a collection of strings to the client advertizing features this provider supports.
/// </summary>
/// <param name="requestObject">An object passed in from the CORE that contains functions that can be used to interact with the CORE and HOST</param>
public void GetFeatures(IRequestObject requestObject)
{
try {
// create a strongly-typed request object.
using (var request = requestObject.As <T>()) {
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::GetFeatures' ", ProviderName);
// Check to see if we're ok to proceed.
if (!request.IsReady(false))
{
return;
}
foreach (var feature in _features)
{
request.Yield(feature);
}
}
}
catch (Exception e) {
// We shoudn't throw exceptions from here, it's not-optimal. And if the exception class wasn't properly Serializable, it'd cause other issues.
// Really this is just here as a precautionary to behave correctly.
// At the very least, we'll write it to the system debug channel, so a developer can find it if they are looking for it.
Debug.WriteLine(string.Format("Unexpected Exception thrown in '{0}::GetFeatures' -- {1}\\{2}\r\n{3}", ProviderName, e.GetType().Name, e.Message, e.StackTrace));
}
}
/// <summary>
///
/// </summary>
/// <param name="fastPackageReference"></param>
/// <param name="requestObject">An object passed in from the CORE that contains functions that can be used to interact with the CORE and HOST</param>
public void InstallPackage(string fastPackageReference, IRequestObject requestObject)
{
try {
// create a strongly-typed request object.
using (var request = requestObject.As <T>()) {
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::InstallPackage' '{1}'", ProviderName, fastPackageReference);
// Check to see if we're ok to proceed.
if (!request.IsReady(true))
{
return;
}
var pkgRef = request.GetPackageByFastpath(fastPackageReference);
if (pkgRef == null)
{
request.Error(ErrorCategory.InvalidArgument, fastPackageReference, Constants.Messages.UnableToResolvePackage);
return;
}
var dependencies = request.GetUninstalledPackageDependencies(pkgRef).Reverse().ToArray();
int progressId = 0;
if (dependencies.Length > 0)
{
progressId = request.StartProgress(0, "Installing package '{0}'", pkgRef.GetCanonicalId(request));
}
var n = 0;
foreach (var d in dependencies)
{
request.Progress(progressId, (n * 100 / (dependencies.Length + 1)) + 1, "Installing dependent package '{0}'", d.GetCanonicalId(request));
if (!request.InstallSinglePackage(d))
{
request.Error(ErrorCategory.InvalidResult, pkgRef.GetCanonicalId(request), Constants.Messages.DependentPackageFailedInstall, d.GetCanonicalId(request));
return;
}
n++;
request.Progress(progressId, (n * 100 / (dependencies.Length + 1)), "Installed dependent package '{0}'", d.GetCanonicalId(request));
}
// got this far, let's install the package we came here for.
if (!request.InstallSinglePackage(pkgRef))
{
// package itself didn't install.
// roll that back out everything we did install.
// and get out of here.
request.Error(ErrorCategory.InvalidResult, pkgRef.GetCanonicalId(request), Constants.Messages.PackageFailedInstall, pkgRef.GetCanonicalId(request));
request.CompleteProgress(progressId, false);
}
request.CompleteProgress(progressId, true);
}
}
catch (Exception e) {
// We shoudn't throw exceptions from here, it's not-optimal. And if the exception class wasn't properly Serializable, it'd cause other issues.
// Really this is just here as a precautionary to behave correctly.
// At the very least, we'll write it to the system debug channel, so a developer can find it if they are looking for it.
Debug.WriteLine(string.Format("Unexpected Exception thrown in '{0}::InstallPackage' -- {1}\\{2}\r\n{3}", ProviderName, e.GetType().Name, e.Message, e.StackTrace));
}
}
/// <summary>
/// Removes/Unregisters a package source
/// </summary>
/// <param name="name">The name or location of a package source to remove.</param>
/// <param name="requestObject">An object passed in from the CORE that contains functions that can be used to interact with the CORE and HOST</param>
public void RemovePackageSource(string name, IRequestObject requestObject)
{
try {
// create a strongly-typed request object.
using (var request = requestObject.As <T>()) {
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::RemovePackageSource' '{1}'", ProviderName, name);
var src = request.FindRegisteredSource(name);
if (src == null)
{
request.Warning(Constants.Messages.UnableToResolveSource, name);
return;
}
request.RemovePackageSource(src.Name);
request.YieldPackageSource(src.Name, src.Location, src.Trusted, false, src.IsValidated);
}
}
catch (Exception e) {
// We shoudn't throw exceptions from here, it's not-optimal. And if the exception class wasn't properly Serializable, it'd cause other issues.
// Really this is just here as a precautionary to behave correctly.
// At the very least, we'll write it to the system debug channel, so a developer can find it if they are looking for it.
Debug.WriteLine(string.Format("Unexpected Exception thrown in '{0}::RemovePackageSource' -- {1}\\{2}\r\n{3}", ProviderName, e.GetType().Name, e.Message, e.StackTrace));
}
}
public void InitializeProvider(RequestImpl requestImpl)
{
if (requestImpl == null)
{
throw new ArgumentNullException("requestImpl");
}
var req = requestImpl.As <Request>();
req.Debug("Initializing PowerShell MetaProvider");
// to do : get modules to load (from configuration ?)
var modules = ScanForModules(req).ToArray();
req.Debug("Scanned for PowerShell Provider Modules ");
// try to create each module at least once.
Parallel.ForEach(modules, modulePath => {
var provider = Create(modulePath);
if (provider != null)
{
if (provider.GetPackageProviderName() != null)
{
// looks good to me, let's add this to the list of moduels this meta provider can create.
_packageProviders.AddOrSet(provider.GetPackageProviderName(), provider);
}
else
{
provider.Dispose();
provider = null;
}
}
});
req.Debug("Loaded PowerShell Provider Modules ");
}
public void DownloadFile(Uri remoteLocation, string localFilename, IRequestObject requestObject)
{
Activity();
// check the Uri type, see if we have anyone who can handle that
// if so, call that provider's download file
if (remoteLocation == null)
{
throw new ArgumentNullException("remoteLocation");
}
if (requestObject == null)
{
throw new ArgumentNullException("requestObject");
}
using (var request = requestObject.As <Request>()) {
foreach (var downloader in PackageManager._instance.Downloaders.Values)
{
if (downloader.SupportedUriSchemes.Contains(remoteLocation.Scheme, StringComparer.OrdinalIgnoreCase))
{
downloader.DownloadFile(remoteLocation, localFilename, request);
return;
}
}
request.Error(ErrorCategory.NotImplemented, Constants.Messages.ProtocolNotSupported, remoteLocation.Scheme, Constants.Messages.ProtocolNotSupported, remoteLocation.Scheme);
}
}
public override void GetDynamicOptions(string category, IRequestObject requestObject)
{
using (var request = requestObject.As <ChocolateyRequest>()) {
try {
request.Debug("Calling '{0}::GetDynamicOptions' '{1}'", ProviderName, category);
switch ((category ?? string.Empty).ToLowerInvariant())
{
case "package":
request.YieldDynamicOption("FilterOnTag", global::OneGet.ProviderSDK.Constants.OptionType.StringArray, false);
request.YieldDynamicOption("Contains", global::OneGet.ProviderSDK.Constants.OptionType.String, false);
request.YieldDynamicOption("AllowPrereleaseVersions", global::OneGet.ProviderSDK.Constants.OptionType.Switch, false);
break;
case "source":
request.YieldDynamicOption("ConfigFile", global::OneGet.ProviderSDK.Constants.OptionType.String, false);
request.YieldDynamicOption("SkipValidate", global::OneGet.ProviderSDK.Constants.OptionType.Switch, false);
break;
case "install":
request.YieldDynamicOption("SkipDependencies", global::OneGet.ProviderSDK.Constants.OptionType.Switch, false);
request.YieldDynamicOption("ContinueOnFailure", global::OneGet.ProviderSDK.Constants.OptionType.Switch, false);
request.YieldDynamicOption("ExcludeVersion", global::OneGet.ProviderSDK.Constants.OptionType.Switch, false);
request.YieldDynamicOption("PackageSaveMode", global::OneGet.ProviderSDK.Constants.OptionType.String, false, new[] {
"nuspec", "nupkg", "nuspec;nupkg"
});
break;
}
}
catch {
// this makes it ignore new OptionCategories that it doesn't know about.
}
}
}
/*
* private IEnumerable<SoftwareIdentity> FindPackagesByUrisImpl(CancellationTokenSource cancellationTokenSource, Uri[] uris, IRequestObject requestObject) {
* var id = StartFind(requestObject);
* foreach (var uri in uris) {
* foreach (var pkg in FindPackageByUri(uri, id.Value, requestObject).TakeWhile(pkg => !cancellationTokenSource.IsCancellationRequested)) {
* yield return pkg;
* }
* foreach (var pkg in CompleteFind(id.Value, requestObject).TakeWhile(pkg => !cancellationTokenSource.IsCancellationRequested)) {
* yield return pkg;
* }
* }
* }
*/
public IAsyncEnumerable <SoftwareIdentity> FindPackagesByFiles(string[] filenames, IRequestObject requestObject)
{
if (requestObject == null)
{
throw new ArgumentNullException("requestObject");
}
if (filenames == null)
{
throw new ArgumentNullException("filenames");
}
if (filenames.Length == 0)
{
return(new EmptyAsyncEnumerable <SoftwareIdentity>());
}
if (filenames.Length == 1)
{
return(FindPackageByFile(filenames[0], 0, requestObject));
}
return(new SoftwareIdentityRequestObject(this, requestObject.As <IHostApi>(), request => {
var id = StartFind(request);
foreach (var file in filenames)
{
Provider.FindPackageByFile(file, id.Value, request);
}
Provider.CompleteFind(id.Value, request);
}, Constants.PackageStatus.Available));
}
public string GetKnownFolder(string knownFolder, RequestImpl requestImpl)
{
if (requestImpl == null)
{
throw new ArgumentNullException("requestImpl");
}
using (var request = requestImpl.As <Request>()) {
request.Debug("Calling 'CommonServiceProvider::GetKnownFolder'");
if (!string.IsNullOrEmpty(knownFolder))
{
if (knownFolder.Equals("tmp", StringComparison.OrdinalIgnoreCase) || knownFolder.Equals("temp", StringComparison.OrdinalIgnoreCase))
{
return(FilesystemExtensions.TempPath);
}
KnownFolder folder;
if (Enum.TryParse(knownFolder, true, out folder))
{
return(KnownFolders.GetFolderPath(folder));
}
}
request.Error(ErrorCategory.InvalidArgument, knownFolder, Constants.UnknownFolderId, knownFolder);
}
return(null);
}
/// <summary>
/// Finds packages given a locally-accessible filename
/// Package information must be returned using <c>request.YieldPackage(...)</c> function.
/// </summary>
/// <param name="file">the full path to the file to determine if it is a package</param>
/// <param name="id">
/// if this is greater than zero (and the number should have been generated using <c>StartFind(...)</c>,
/// the core is calling this multiple times to do a batch search request. The operation can be delayed until
/// <c>CompleteFind(...)</c> is called
/// </param>
/// <param name="requestImpl">
/// An object passed in from the CORE that contains functions that can be used to interact with
/// the CORE and HOST
/// </param>
public void FindPackageByFile(string file, int id, RequestImpl requestImpl)
{
try {
// create a strongly-typed request object.
using (var request = requestImpl.As <Request>()) {
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::FindPackageByFile' '{1}','{2}'", ProviderName, file, id);
if (!file.FileExists())
{
request.Error(ErrorCategory.ObjectNotFound, file, Constants.Messages.UnableToResolvePackage, file);
return;
}
try {
var package = new InstallPackage(file, DatabaseOpenMode.ReadOnly);
YieldPackage(package, file, request);
package.Close();
} catch (Exception e) {
e.Dump();
// any exception at this point really just means that
request.Error(ErrorCategory.OpenError, file, Constants.Messages.UnableToResolvePackage, file);
}
}
} catch (Exception e) {
// We shoudn't throw exceptions from here, it's not-optimal. And if the exception class wasn't properly Serializable, it'd cause other issues.
// Really this is just here as a precautionary to behave correctly.
// At the very least, we'll write it to the system debug channel, so a developer can find it if they are looking for it.
Debug.WriteLine("Unexpected Exception thrown in '{0}::FindPackageByFile' -- {1}\\{2}\r\n{3}", ProviderName, e.GetType().Name, e.Message, e.StackTrace);
}
}
public void SetEnvironmentVariable(string variable, string value, int context, RequestImpl requestImpl)
{
if (requestImpl == null)
{
throw new ArgumentNullException("requestImpl");
}
using (var request = requestImpl.As <Request>()) {
request.Debug("Calling 'CommonServiceProvider::SetEnvironmentVariable'");
if (string.IsNullOrEmpty(value))
{
RemoveEnvironmentVariable(variable, context, requestImpl);
}
switch ((EnvironmentContext)context)
{
case EnvironmentContext.System:
if (!IsElevated(requestImpl))
{
request.Warning("SetEnvironmentVariable Failed - Admin Elevation required to set variable '{0}' in machine context", variable);
return;
}
request.Verbose("SetEnvironmentVariable (machine) '{0}' = '{1}'", variable, value);
Environment.SetEnvironmentVariable(variable, value, EnvironmentVariableTarget.Machine);
break;
default:
request.Verbose("SetEnvironmentVariable (user) '{0}' = '{1}'", variable, value);
Environment.SetEnvironmentVariable(variable, value, EnvironmentVariableTarget.User);
break;
}
Environment.SetEnvironmentVariable(variable, null, EnvironmentVariableTarget.Process);
}
}
public void InitializeProvider(RequestImpl requestImpl)
{
using (var request = requestImpl.As <Request>()) {
// use the request object to interact with the OneGet core:
request.Debug("Calling 'InitializeProvider'");
}
}
public IEnumerable <PackageProvider> SelectProviders(string providerName, RequestImpl requestImpl)
{
if (providerName.Is())
{
// strict name match for now.
if (_packageProviders.ContainsKey(providerName))
{
return(_packageProviders[providerName].SingleItemAsEnumerable().ByRef());
}
if (requestImpl != null)
{
// if the end user requested a provider that's not there. perhaps the bootstrap provider can find it.
if (RequirePackageProvider(null, providerName, Constants.MinVersion, requestImpl))
{
// seems to think we found it.
if (_packageProviders.ContainsKey(providerName))
{
return(_packageProviders[providerName].SingleItemAsEnumerable().ByRef());
}
}
var hostApi = requestImpl.As <IHostApi>();
// warn the user that that provider wasn't found.
hostApi.Warning(hostApi.FormatMessageString(Constants.UnknownProvider, providerName));
}
return(Enumerable.Empty <PackageProvider>().ByRef());
}
return(PackageProviders.ByRef());
}
/// <summary>
/// Determines whether [is] [the specified object].
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj">The object.</param>
/// <returns><c>true</c> if [is] [the specified object]; otherwise, <c>false</c>.</returns>
/// <exception cref="System.NullReferenceException">obj</exception>
public static bool Is <T>(this Object obj)
{
if (obj == null)
{
throw new NullReferenceException("obj");
}
if (typeof(T) == typeof(string))
{
return(true);
}
if (obj.GetType() == typeof(string) && typeof(T).IsValueType)
{
try
{
obj.As <T>();
return(true);
}
catch (Exception)
{
return(false);
}
}
return(typeof(T).IsAssignableFrom(obj.GetType()));
}
public void CopyFile(string sourcePath, string destinationPath, IRequestObject requestObject)
{
Activity();
if (requestObject == null)
{
throw new ArgumentNullException("requestObject");
}
using (var request = requestObject.As <Request>()) {
request.Debug("Calling 'ProviderService::CopyFile'");
if (sourcePath == null)
{
throw new ArgumentNullException("sourcePath");
}
if (destinationPath == null)
{
throw new ArgumentNullException("destinationPath");
}
if (File.Exists(destinationPath))
{
destinationPath.TryHardToDelete();
if (File.Exists(destinationPath))
{
request.Error(ErrorCategory.OpenError, destinationPath, Constants.Messages.UnableToOverwriteExistingFile, destinationPath);
}
}
File.Copy(sourcePath, destinationPath);
if (!File.Exists(destinationPath))
{
request.Error(ErrorCategory.InvalidResult, destinationPath, Constants.Messages.UnableToCopyFileTo, destinationPath);
}
}
}
public IEnumerable <PackageProvider> SelectProviders(string providerName, IRequestObject requestObject)
{
if (providerName.Is())
{
// match with wildcards
var results = _packageProviders.Values.Where(each => each.ProviderName.IsWildcardMatch(providerName)).ReEnumerable();
if (results.Any())
{
return(results.ByRef());
}
if (requestObject != null && !providerName.ContainsWildcards())
{
// if the end user requested a provider that's not there. perhaps the bootstrap provider can find it.
if (RequirePackageProvider(null, providerName, Constants.MinVersion, requestObject))
{
// seems to think we found it.
if (_packageProviders.ContainsKey(providerName))
{
return(_packageProviders[providerName].SingleItemAsEnumerable().ByRef());
}
}
var hostApi = requestObject.As <IHostApi>();
// warn the user that that provider wasn't found.
hostApi.Warning(hostApi.FormatMessageString(Constants.Messages.UnknownProvider, providerName));
}
return(Enumerable.Empty <PackageProvider>().ByRef());
}
return(PackageProviders.ByRef());
}
/// <summary>
/// Returns dynamic option definitions to the HOST
/// </summary>
/// <param name="category">The category of dynamic options that the HOST is interested in</param>
/// <param name="requestObject">
/// An object passed in from the CORE that contains functions that can be used to interact with
/// the CORE and HOST
/// </param>
public void GetDynamicOptions(string category, IRequestObject requestObject)
{
try {
// create a strongly-typed request object.
using (var request = requestObject.As <Request>()) {
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::GetDynamicOptions' '{1}'", ProviderName, category);
switch ((category ?? string.Empty).ToLowerInvariant())
{
case "install":
// options required for install/uninstall/getinstalledpackages
break;
case "provider":
// options used with this provider. Not currently used.
break;
case "source":
// options for package sources
break;
case "package":
// options used when searching for packages
break;
}
}
} catch (Exception e) {
// We shoudn't throw exceptions from here, it's not-optimal. And if the exception class wasn't properly Serializable, it'd cause other issues.
// Really this is just here as a precautionary to behave correctly.
// At the very least, we'll write it to the system debug channel, so a developer can find it if they are looking for it.
Debug.WriteLine("Unexpected Exception thrown in '{0}::GetDynamicOptions' -- {1}\\{2}\r\n{3}", ProviderName, e.GetType().Name, e.Message, e.StackTrace);
}
}
/*
* private IEnumerable<SoftwareIdentity> FindPackagesImpl(CancellationTokenSource cancellationTokenSource, string[] names, string requiredVersion, string minimumVersion, string maximumVersion, IRequestObject requestObject) {
* var id = StartFind(requestObject);
* foreach (var name in names) {
* foreach (var pkg in FindPackage(name, requiredVersion, minimumVersion, maximumVersion, id, requestObject).TakeWhile(pkg => !cancellationTokenSource.IsCancellationRequested)) {
* yield return pkg;
* }
* foreach (var pkg in CompleteFind(id, requestObject).TakeWhile(pkg => !cancellationTokenSource.IsCancellationRequested)) {
* yield return pkg;
* }
* }
* }
*/
public IAsyncEnumerable <SoftwareIdentity> FindPackagesByUris(Uri[] uris, IRequestObject requestObject)
{
if (requestObject == null)
{
throw new ArgumentNullException("requestObject");
}
if (uris == null)
{
throw new ArgumentNullException("uris");
}
if (uris.Length == 0)
{
return(new EmptyAsyncEnumerable <SoftwareIdentity>());
}
if (uris.Length == 1)
{
return(FindPackageByUri(uris[0], 0, requestObject));
}
return(new SoftwareIdentityRequestObject(this, requestObject.As <IHostApi>(), request => {
var id = StartFind(request);
foreach (var uri in uris)
{
Provider.FindPackageByUri(uri, id.Value, request);
}
Provider.CompleteFind(id.Value, request);
}, Constants.PackageStatus.Available));
}
public IAsyncEnumerable <SoftwareIdentity> FindPackages(string[] names, string requiredVersion, string minimumVersion, string maximumVersion, IRequestObject requestObject)
{
if (requestObject == null)
{
throw new ArgumentNullException("requestObject");
}
if (names == null)
{
throw new ArgumentNullException("names");
}
if (names.Length == 0)
{
return(FindPackage(null, requiredVersion, minimumVersion, maximumVersion, 0, requestObject));
}
if (names.Length == 1)
{
return(FindPackage(names[0], requiredVersion, minimumVersion, maximumVersion, 0, requestObject));
}
return(new SoftwareIdentityRequestObject(this, requestObject.As <IHostApi>(), request => {
var id = StartFind(request);
foreach (var name in names)
{
Provider.FindPackage(name, requiredVersion, minimumVersion, maximumVersion, id.Value, request);
}
Provider.CompleteFind(id.Value, request);
}, Constants.PackageStatus.Available));
}
public void CreateFolder(string folder, IRequestObject requestObject)
{
Activity();
if (requestObject == null)
{
throw new ArgumentNullException("requestObject");
}
using (var request = requestObject.As <Request>()) {
request.Debug("Calling 'ProviderService::CreateFolder'");
if (!Directory.Exists(folder))
{
try {
Directory.CreateDirectory(folder);
request.Verbose("CreateFolder Success {0}", folder);
return;
} catch (Exception e) {
request.Error(ErrorCategory.InvalidResult, folder, Constants.Messages.CreatefolderFailed, folder, e.Message);
return;
}
}
request.Verbose("CreateFolder -- Already Exists {0}", folder);
}
}
public bool ExecuteElevatedAction(string provider, string payload, IRequestObject requestObject)
{
Activity();
if (requestObject == null)
{
throw new ArgumentNullException("requestObject");
}
// launches a new elevated host that
// talks back to this (unelevated) host for everything in HostApi
// everything else should be handled in the new process.
var guid = Guid.NewGuid();
var properties = new Hashtable();
properties.Add("portName", "OneGet_" + guid);
properties.Add("authorizedGroup", "Administrators");
properties.Add("secure", "true");
properties.Add("exclusiveAddressUse", "true");
properties.Add("strictBinding", "false");
properties.Add("name", "OneGetHost");
// set up the server IPC channel
var serverChannel = new IpcServerChannel(properties, new BinaryServerFormatterSinkProvider(properties, null));
ChannelServices.RegisterChannel(serverChannel, true);
var instance = new RemotableHostApi(requestObject.As <IHostApi>());
var objRef = RemotingServices.Marshal(instance, "Host", typeof(IHostApi));
var remoteUris = serverChannel.GetUrlsForUri("Host");
var uri = remoteUris[0];
// Create the client elevated
try {
var process = AsyncProcess.Start(new ProcessStartInfo {
FileName = Assembly.GetExecutingAssembly().Location,
Arguments = "{0} {1} {2}".format(uri, provider, (string.IsNullOrWhiteSpace(payload) ? "null" : payload).ToBase64()),
#if !DEBUG
WindowStyle = ProcessWindowStyle.Hidden,
#endif
Verb = "runas",
});
process.WaitForExit();
if (process.ExitCode != 0)
{
return(false);
}
} catch (Exception e) {
e.Dump();
return(false);
} finally {
RemotingServices.Disconnect(instance);
ChannelServices.UnregisterChannel(serverChannel);
}
return(true);
}
public int StartFind(RequestImpl requestImpl)
{
if (requestImpl == null)
{
throw new ArgumentNullException("requestImpl");
}
return(Provider.StartFind(requestImpl.As <IRequest>()));
}
public IAsyncValue <int> StartFind(IRequestObject requestObject)
{
if (requestObject == null)
{
throw new ArgumentNullException("requestObject");
}
return(new FuncRequestObject <int>(this, requestObject.As <IHostApi>(), request => Provider.StartFind(request)));
}
public void InitializeProvider(object dynamicInterface, RequestImpl requestImpl)
{
RequestExtensions.RemoteDynamicInterface = dynamicInterface;
using (var request = requestImpl.As <Request>()) {
// use the request object to interact with the OneGet core:
request.Debug("Information", "Calling 'InitializeProvider'");
}
}
public static void Write(Object value)
{
var con = Script.ToDynamic().Bridge.global.console;
if (con && con.log)
{
con.log(value.As <dynamic>());
}
}
internal IRequest ExtendRequest(RequestImpl requestImpl, params object[] objects)
{
var baseGetMessageString = requestImpl.As <GetMessageString>();
return(requestImpl.Extend <IRequest>(new {
// check the caller's resource manager first, then fall back to this resource manager
GetMessageString = new Func <string, string>((s) => baseGetMessageString(s) ?? Messages.ResourceManager.GetString(s)),
}, objects, AdditionalImplementedFunctions));
}
public void InitializeProvider(IRequestObject requestObject)
{
// we should go find out what's available once here just to make sure that
// we have a list
try {
PackageManager._instance.BootstrappableProviderNames = GetProviders(requestObject.As <BootstrapRequest>()).Select(provider => provider.Attributes["name"]).ToArray();
} catch {
}
}
public void DownloadFile(Uri remoteLocation, string localFilename, RequestImpl requestImpl)
{
// TODO: Fill in implementation
// Delete this method if you do not need to implement it
// Please don't throw an not implemented exception, it's not optimal.
using (var request = requestImpl.As <Request>()) {
// use the request object to interact with the OneGet core:
request.Debug("Information", "Calling 'DownloadFile'");
}
}
public void UnpackArchive(string localFilename, string destinationFolder, RequestImpl requestImpl)
{
// TODO: Fill in implementation
// Delete this method if you do not need to implement it
// Please don't throw an not implemented exception, it's not optimal.
using (var request = requestImpl.As <Request>()) {
// use the request object to interact with the OneGet core:
request.Debug("Information", "Calling 'UnpackArchive'");
}
}
internal static PsRequest New(Object requestObject, PowerShellProviderBase provider, string methodName) {
if (requestObject is IAsyncAction) {
((IAsyncAction)(requestObject)).OnCancel += provider.CancelRequest;
((IAsyncAction)(requestObject)).OnAbort += provider.CancelRequest;
}
var req = requestObject.As<PsRequest>();
req.CommandInfo = provider.GetMethod(methodName);
if (req.CommandInfo == null) {
req.Debug("METHOD_NOT_IMPLEMENTED", methodName);
}
req._provider = provider;
if (req.Options == null) {
req.Debug("req.Options is null");
} else {
req.Debug("Calling New() : MethodName = '{0}'", methodName);
foreach(string key in req.Options.Keys)
{
req.Debug(String.Format(CultureInfo.CurrentCulture, "{0}: {1}", key, req.Options[key]));
}
}
return req;
}
internal static PsRequest New(Object requestObject, PowerShellProviderBase provider, string methodName)
{
if (requestObject is IAsyncAction) {
((IAsyncAction)(requestObject)).OnCancel += provider.CancelRequest;
((IAsyncAction)(requestObject)).OnAbort += provider.CancelRequest;
}
var req = requestObject.As<PsRequest>();
req.CommandInfo = provider.GetMethod(methodName);
if (req.CommandInfo == null) {
req.Debug("METHOD_NOT_IMPLEMENTED", methodName);
}
req._provider = provider;
return req;
}