public void AddByAasPackage(PackageCentral packageCentral, AdminShellPackageEnv env, string fn)
{
// access
if (env == null)
{
return;
}
// ok, add
var fi = PackageContainerFactory.GuessAndCreateFor(
packageCentral,
location: fn,
fullItemLocation: fn,
overrideLoadResident: false,
containerOptions: PackageContainerOptionsBase.CreateDefault(Options.Curr));
if (fi is PackageContainerRepoItem ri)
{
fi.Env = env;
ri.CalculateIdsTagAndDesc();
ri.VisualState = PackageContainerRepoItem.VisualStateEnum.ReadFrom;
ri.VisualTime = 2.0;
this.Add(ri);
}
}
public PackageContainerNetworkHttpFile(
PackageCentral packageCentral,
string sourceFn, PackageContainerOptionsBase containerOptions = null)
: base(packageCentral)
{
Init();
SetNewLocation(sourceFn);
if (containerOptions != null)
{
ContainerOptions = containerOptions;
}
}
public static PackageContainerBase GuessAndCreateFor(
PackageCentral packageCentral,
string location,
string fullItemLocation,
bool overrideLoadResident,
PackageContainerBase takeOver = null,
PackageContainerListBase containerList = null,
PackageContainerOptionsBase containerOptions = null,
PackCntRuntimeOptions runtimeOptions = null)
{
var task = Task.Run(() => GuessAndCreateForAsync(
packageCentral, location, fullItemLocation, overrideLoadResident,
takeOver, containerList, containerOptions, runtimeOptions));
return(task.Result);
}
public bool Load(
PackageCentral packageCentral,
string location,
string fullItemLocation,
bool overrideLoadResident,
PackageContainerOptionsBase containerOptions = null,
PackCntRuntimeOptions runtimeOptions = null)
{
try
{
// close old one
if (Container != null)
{
if (Container.IsOpen)
{
Container.Close();
}
Container = null;
}
// figure out, what to load
var task = Task.Run(async() => await PackageContainerFactory.GuessAndCreateForAsync(
packageCentral,
location,
fullItemLocation,
overrideLoadResident,
null, null,
containerOptions,
runtimeOptions));
var guess = task.Result;
if (guess == null)
{
return(false);
}
// success!
Container = guess;
return(true);
}
catch (Exception ex)
{
throw new PackageCentralException(
$"PackageCentral: while performing load from {location} " +
$"at {AdminShellUtil.ShortLocation(ex)} gave: {ex.Message}", ex);
}
}
public static async Task <PackageContainerLocalFile> CreateAndLoadAsync(
PackageCentral packageCentral,
string location,
string fullItemLocation,
bool overrideLoadResident,
PackageContainerBase takeOver = null,
PackageContainerOptionsBase containerOptions = null,
PackCntRuntimeOptions runtimeOptions = null)
{
var res = new PackageContainerLocalFile(
CopyMode.Serialized, takeOver,
packageCentral, location, containerOptions);
if (overrideLoadResident || true == res.ContainerOptions?.LoadResident)
{
await res.LoadFromSourceAsync(fullItemLocation, runtimeOptions);
}
return(res);
}
//
// Constructor
//
public static PackageContainerOptionsBase CreateDefault(
OptionsInformation opts,
bool loadResident = false)
{
// first act
var res = new PackageContainerOptionsBase();
res.LoadResident = loadResident;
if (opts == null)
{
return(res);
}
// now take some user options, as well
res.StayConnected = opts.DefaultStayConnected;
res.UpdatePeriod = Math.Max(OptionsInformation.MinimumUpdatePeriod, opts.DefaultUpdatePeriod);
// ok
return(res);
}
public PackageContainerNetworkHttpFile(CopyMode mode, PackageContainerBase other,
PackageCentral packageCentral = null,
string sourceUri = null, PackageContainerOptionsBase containerOptions = null)
: base(mode, other, packageCentral)
{
if ((mode & CopyMode.Serialized) > 0 && other != null)
{
}
if ((mode & CopyMode.BusinessData) > 0 && other is PackageContainerNetworkHttpFile o)
{
sourceUri = o.Location;
}
if (sourceUri != null)
{
SetNewLocation(sourceUri);
}
if (containerOptions != null)
{
ContainerOptions = containerOptions;
}
}
public async Task <List <PackageContainerRepoItem> > GenerateRepositoryFromEndpointAsync()
{
// access
if (!IsValid())
{
throw new PackageConnectorException("PackageConnector::GenerateRepositoryFromEndpoint() " +
"connection not valid!");
}
// results
var res = new List <PackageContainerRepoItem>();
// Log
Log.Singleton.Info($"Building repository items for aas-list from {this.ToString()} ..");
// sync-query for the list
var aasItems = new List <ListAasItem>();
try
{
if (OpenIDClient.auth)
{
var responseAuth = _client.GetAsync("/authserver").Result;
if (responseAuth.IsSuccessStatusCode)
{
var content = responseAuth.Content.ReadAsStringAsync().Result;
if (content != null && content != "")
{
OpenIDClient.authServer = content;
var response2 = await OpenIDClient.RequestTokenAsync(null);
OpenIDClient.token = response2.AccessToken;
OpenIDClient.auth = false;
}
}
}
if (OpenIDClient.token != "")
{
_client.SetBearerToken(OpenIDClient.token);
}
// query
var listAasResponse = await _client.GetAsync(
StartQuery("server", "listaas"));
listAasResponse.EnsureSuccessStatusCode();
var listAasString = await listAasResponse.Content.ReadAsStringAsync();
// get some structures
dynamic listAas = Newtonsoft.Json.Linq.JObject.Parse(listAasString);
foreach (var li in listAas.aaslist)
{
string line = "" + li;
var arr = line.Trim().Split(new[] { " : " }, StringSplitOptions.RemoveEmptyEntries);
if (arr.Length == 4)
{
aasItems.Add(new ListAasItem()
{
Index = arr[0].Trim(),
AasIdShort = arr[1].Trim(),
AasId = arr[2].Trim(),
Fn = arr[3].Trim()
});
}
}
}
catch (Exception ex)
{
Log.Singleton.Error(ex, $"when parsing /server/listaas/ for {this.ToString()}");
}
// go thru the list
foreach (var aasi in aasItems)
{
try
{
// query
var x = await GetAasAssetCore(aasi.Index);
if (x.Item1 == null || x.Item2 == null)
{
Log.Singleton.Error($"when retrieving /aas/{aasi.Index}/, some null contents for AAS or" +
$"Asset were found.");
}
// file item
var fi = new PackageContainerRepoItem()
{
ContainerOptions = PackageContainerOptionsBase.CreateDefault(Options.Curr),
Location = CombineQuery(_client.BaseAddress.ToString(), _endPointSegments,
"server", "getaasx", aasi.Index),
Description = $"\"{"" + x.Item1?.idShort}\",\"{"" + x.Item2?.idShort}\"",
Tag = "" + AdminShellUtil.ExtractPascalCasingLetters(x.Item1?.idShort).SubstringMax(0, 3)
};
fi.AasIds.Add("" + x.Item1?.identification?.id);
fi.AssetIds.Add("" + x.Item2?.identification?.id);
res.Add(fi);
}
catch (Exception ex)
{
Log.Singleton.Error(ex, $"when parsing index {aasi.Index}");
}
}
// return results
return(res);
}
public static async Task <PackageContainerBase> Demo(
PackageCentral packageCentral,
string location,
bool overrideLoadResident,
PackageContainerOptionsBase containerOptions = null,
PackCntRuntimeOptions ro = null)
{
// Log location
ro?.Log?.Info($"Perform Demo() for location {location}");
// ask for a list
var li1 = new List <AnyUiDialogueListItem>();
li1.Add(new AnyUiDialogueListItem("AAAAAAAAAAAAAAAAAAAAAAAAAAA", "A"));
li1.Add(new AnyUiDialogueListItem("bbbbbbbbbbbb", "B"));
li1.Add(new AnyUiDialogueListItem("CCCCCCCCCCCCCCCCCC CCCCC", "C"));
var waitLi1 = new TaskCompletionSource <AnyUiDialogueListItem>();
ro?.AskForSelectFromList?.Invoke("Testselect", li1, waitLi1);
var xx = await waitLi1.Task;
ro?.Log?.Info($".. selected item is {"" + xx?.Text}");
// ask for a list
var li2 = new List <AnyUiDialogueListItem>();
li2.Add(new AnyUiDialogueListItem("111111111", "A"));
li2.Add(new AnyUiDialogueListItem("222222222222222222222222", "B"));
li2.Add(new AnyUiDialogueListItem("3333333333333 3333", "C"));
var waitLi2 = new TaskCompletionSource <AnyUiDialogueListItem>();
ro?.AskForSelectFromList?.Invoke("Testselect", li2, waitLi2);
var xy = await waitLi2.Task;
ro?.Log?.Info($".. selected item is {"" + xy?.Text}");
// ask for credentials
var waitCre = new TaskCompletionSource <PackageContainerCredentials>();
ro?.AskForCredentials?.Invoke("Fill user credentials", waitCre);
var xz = await waitCre.Task;
ro?.Log?.Info($".. credentials are {"" + xz?.Username} and {"" + xz?.Password}");
// debug some important blocks of text
ro?.Log?.Info(StoredPrint.Color.Yellow, "Showing fingerprint:");
var sum = "";
for (int i = 0; i < 1000; i++)
{
sum += $"{i} ";
}
ro?.Log?.Info($"Showing fingerprint: {sum}");
// done
ro?.Log?.Info($".. demo loading from internet ..");
return(await PackageContainerNetworkHttpFile.CreateAndLoadAsync(
packageCentral,
"http://admin-shell-io.com:51310/server/getaasx/0",
"http://admin-shell-io.com:51310/server/getaasx/0",
// "http://localhost:51310/server/getaasx/0",
overrideLoadResident, null, null, containerOptions, ro));
}
public static async Task <PackageContainerBase> GuessAndCreateForAsync(
PackageCentral packageCentral,
string location,
string fullItemLocation,
bool overrideLoadResident,
PackageContainerBase takeOver = null,
PackageContainerListBase containerList = null,
PackageContainerOptionsBase containerOptions = null,
PackCntRuntimeOptions runtimeOptions = null)
{
// access
if (location == null)
{
return(null);
}
var ll = location.ToLower();
// guess
runtimeOptions?.Log?.Info($"Trying to guess package container for {location} ..");
var guess = PackageContainerGuess.FromLocation(location, runtimeOptions);
if (guess == null)
{
runtimeOptions?.Log?.Info("Aborting");
return(null);
}
// start
runtimeOptions?.Log?.Info($".. with containerOptions = {containerOptions?.ToString()}");
// TODO (MIHO, 2021-02-01): check, if demo option is still required
if (ll.Contains("/demo"))
{
return(await Demo(packageCentral, location,
overrideLoadResident, containerOptions, runtimeOptions));
}
// starts with http ?
if (guess.GuessedType == typeof(PackageContainerNetworkHttpFile))
{
var cnt = await PackageContainerNetworkHttpFile.CreateAndLoadAsync(
packageCentral, location, fullItemLocation,
overrideLoadResident, takeOver, containerList,
containerOptions, runtimeOptions);
if (cnt.ContainerOptions.StayConnected &&
guess.AasId.HasContent() &&
guess.HeadOfPath.HasContent())
{
cnt.ConnectorPrimary = new PackageConnectorHttpRest(cnt,
new Uri(guess.HeadOfPath + "/aas/" + guess.AasId));
}
return(cnt);
}
// check FileInfo for (possible?) local file
FileInfo fi = null;
try
{
fi = new FileInfo(location);
}
catch (Exception ex)
{
LogInternally.That.SilentlyIgnoredError(ex);
}
// if file, try to open (might throw exceptions!)
if (fi != null)
{
// seems to be a valid (possible) file
return(await PackageContainerLocalFile.CreateAndLoadAsync(
packageCentral, location, fullItemLocation, overrideLoadResident, takeOver, containerOptions));
}
// no??
runtimeOptions?.Log?.Info($".. no any possible option for package container found .. Aborting!");
return(null);
}
