public void Add(BaseXmlConfigFactory factory, string regName, BaseObjectElementAttribute attr, Type type)
{
ObjectElementAttribute objAttr = new ObjectElementAttribute(attr.NamespaceType)
{
LocalName = regName,
ObjectType = type,
UseConstructor = attr.UseConstructor
};
if (attr.NamespaceType == NamespaceType.Namespace)
{
objAttr.NamespaceUri = attr.NamespaceUri;
}
QName qName = objAttr.GetQName(objAttr.LocalName);
VersionData data = ObjectUtil.TryGetValue(fLocalElements, qName.LocalName);
if (data == null)
{
data = new VersionData();
fLocalElements.Add(qName.LocalName, data);
fXmlElements.Add(qName, data);
}
data.Add(attr, objAttr, factory.DefaultVersion);
fTypeElements.Add(type, objAttr);
}
public Task <VersionData> GetVersionDataAsync(int versionId)
{
lock (DB)
{
var versionDoc = DB.Versions.FirstOrDefault(x => x.VersionId == versionId);
if (versionDoc == null)
{
return(Task.FromResult((VersionData)null));
}
var result = new VersionData
{
VersionId = versionDoc.VersionId,
NodeId = versionDoc.NodeId,
Version = versionDoc.Version,
CreationDate = versionDoc.CreationDate,
CreatedById = versionDoc.CreatedById,
ModificationDate = versionDoc.ModificationDate,
ModifiedById = versionDoc.ModifiedById,
ChangedData = versionDoc.ChangedData,
Timestamp = versionDoc.Timestamp,
};
return(Task.FromResult(result));
}
}
private async void Page_Loaded(object sender, RoutedEventArgs e)
{
VersionData versionData = new VersionData();
versionData.CurrentVersion = VERSION;
BaseModule module = ModuleFactory.Get(ModuleFactory.Version);
try
{
Task <bool> processResult = module.Process(versionData);
bool result = await processResult;
if (result == false)
{
Console.WriteLine("Version Mismatch");
loginButton.IsEnabled = false;
MessageBox.Show("Version Mismatch");
}
else
{
loginButton.IsEnabled = true;
Console.WriteLine("Updated Version : " + VERSION);
}
}
catch (Exception ex)
{
Console.WriteLine("ERROR : " + ex.Message);
}
}
protected void GetVersionFromVersionString()
{
GetPEInfo();
// If we can't get the version from the PE, search for version string embedded in the module data
if (_versionData is null && !IsPEImage)
{
string versionString = VersionString;
if (versionString != null)
{
int spaceIndex = versionString.IndexOf(' ');
if (spaceIndex > 0)
{
if (versionString[spaceIndex - 1] == '.')
{
spaceIndex--;
}
string versionToParse = versionString.Substring(0, spaceIndex);
try
{
Version version = System.Version.Parse(versionToParse);
_versionData = new VersionData(version.Major, version.Minor, version.Build, version.Revision);
}
catch (ArgumentException ex)
{
Trace.TraceError($"Module.Version FAILURE: '{versionToParse}' '{versionString}' {ex}");
}
}
}
}
}
public override void AddTelemetryDetail(string ipAddress, VersionData versionInfo, TelemetryItem telemetryItem)
{
ViewTelemetryDetail detail = new ViewTelemetryDetail(telemetryItem.Id)
{
Timestamp = telemetryItem.Timestamp, TelemetrySummary = this, AssemblyVersion = versionInfo.AssemblyVersion, FileVersion = versionInfo.FileVersion, IpAddress = ipAddress,
Sequence = telemetryItem.Sequence,
UserIdentifier = telemetryItem.UserIdentifier,
EntryKey = telemetryItem.EntryKey
};
if (telemetryItem.Properties != null && telemetryItem.Properties.Any())
{
foreach (KeyValuePair <string, string> unit in telemetryItem.Properties)
{
ViewTelemetryUnit telemetryUnit = new ViewTelemetryUnit {
Key = unit.Key, ValueString = unit.Value?.ToString(), UnitType = TelemetryUnit.UnitTypes.Property
};
((List <ViewTelemetryUnit>)detail.TelemetryUnits).Add(telemetryUnit);
}
}
if (telemetryItem.Measurements != null && telemetryItem.Measurements.Any())
{
foreach (KeyValuePair <string, double> unit in telemetryItem.Measurements)
{
ViewTelemetryUnit telemetryUnit = new ViewTelemetryUnit()
{
Key = unit.Key, ValueDouble = unit.Value, UnitType = TelemetryUnit.UnitTypes.Metric
};
((List <ViewTelemetryUnit>)detail.TelemetryUnits).Add(telemetryUnit);
}
}
((List <ViewTelemetryDetail>) this.TelemetryDetails).Add(detail);
}
public VersionData GetVersionNumber(object value)
{
var text = value as string;
if (text != null)
{
var options = RegexOptions.Multiline;
var matches = Regex.Matches(text, RegexExpression, options);
foreach (Match match in matches)
{
var output = new VersionData
{
Hauptversion = System.Convert.ToInt16(match.Groups[Hauptversion].Value),
Nebenversion = System.Convert.ToInt16(match.Groups[Nebenversion].Value),
Buildnummer = System.Convert.ToInt16(match.Groups[Buildnummer].Value),
Revision = System.Convert.ToInt16(match.Groups[Revision].Value)
};
return(output);
}
}
return(null);
}
public void TestVersions()
{
using (ReVersion_DatabaseContext db = new ReVersion_DatabaseContext())
{
FileHierarchyData hierData = new FileHierarchyData(hierarchy);
hierData.AddNode("/A/B/alpha/beTa");
hierData.DeleteNode("F/");
VersionData data = new VersionData
{
RepositoryName = "yetAnotherRepo",
BranchName = "yetAnotherBranch",
ParentBranchName = "yetAnotherOtherBranch",
NewBranch = true,
DeltaContent = "here's Delta!",
//FileHierarchy = hierData.GetHierarchyList(),
EventId = 5
};
SQLOperations.InsertIntoVersionsTable(db, data);
db.SaveChanges();
List <int> versionsActual = SQLOperations.QueryVersions(db, "yetAnotherRepo", "yetAnotherBranch");
List <int> versionsExpected = new List <int> {
1
};
SameListContents(versionsActual, versionsExpected);
}
}
public void ProcessMonitor_GetVersionDataIsValidTest()
{
var versionData = VersionData.GetVersionData(TcpConnectionsViewer.Properties.Settings.Default.StaticVersionUri);
Assert.IsTrue(!string.IsNullOrWhiteSpace(versionData.DownloadUri));
Assert.IsTrue(versionData.IsValid);
}
public static void ConnectToData()
{
ISession session = ThreadLocalSession.CurrentSession();
string strVer = VersionData.GetVersion();
ThreadLocalSession.CloseCurrentSession();
}
// BuildPlayer时将StreamingAssets部署到服务器
public static void DeployStreamingAssetsToHotWhenBuildPlayer()
{
Debug.Log($"开始部署热更文件，Version:{PlayerSettings.bundleVersion} PackageName:{PlayerSettings.applicationIdentifier}");
string srcPath = ABUtility.StreamingAssetsFilePath + "/";
string destPath = $"{m_HotPath}/{PlayerSettings.applicationIdentifier}/{ABUtility.PlatformName}/";
if (Directory.Exists(destPath))
{
Directory.Delete(destPath, true);
}
if (!File.Exists(m_curVersionPath))
{
Debug.LogError($"文件不存在，部署失败：{m_curVersionPath}");
return;
}
VersionData versionData = ReadJsonFile <VersionData>(m_curVersionPath);
foreach (var item in versionData.FileInfoDict)
{
var md5Data = item.Value;
string srcFile = srcPath + md5Data.Name;
string destFile = destPath + md5Data.Name;
if (!File.Exists(srcFile))
{
Debug.LogError($"文件不存在，部署失败{srcFile}");
return;
}
int idx = destFile.LastIndexOf('/');
string p1 = destFile.Substring(0, idx);
Directory.CreateDirectory(p1);
File.Copy(srcFile, destFile);
Debug.Log("已部署：" + md5Data.Name);
}
Debug.Log("部署完毕。路径：" + destPath);
}
private bool ForceNextVersion(VersionData version)
{
bool versionIsBumped;
if (version.Major < this._nextVersion.Major)
{
version.SetNextBump(VersionBump.Major);
versionIsBumped = version.CommitNextBump(this._allowMajorBump);
}
else if (version.Minor < this._nextVersion.Minor)
{
version.SetNextBump(VersionBump.Minor);
versionIsBumped = version.CommitNextBump(this._allowMajorBump);
}
else if (version.Patch < this._nextVersion.Build)
{
version.SetNextBump(VersionBump.Patch);
versionIsBumped = version.CommitNextBump(this._allowMajorBump);
}
else
{
versionIsBumped = version.CommitNextBump(this._allowMajorBump);
if (version.MajorMinorPatch == "0.0.0" && this._nextVersion.ToString(3) == "0.0.0")
{
version.SetNextBump(VersionBump.Major);
versionIsBumped = version.CommitNextBump(this._allowMajorBump);
}
}
return(versionIsBumped);
}
/// <summary>
/// Synchronizes the analysers from server.
/// </summary>
/// <param name="authentication">The authentication.</param>
/// <param name="versionToUse">The version to use.</param>
private bool SyncAnalysersFromServer(ISonarConfiguration authentication, VersionData versionToUse)
{
var tmpFile = Path.GetTempFileName();
var tmpDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
bool isOk = false;
if (File.Exists(tmpFile))
{
File.Delete(tmpFile);
}
try
{
isOk = DownloadFileFromServer(authentication, versionToUse, tmpFile, tmpDir);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
if (File.Exists(tmpFile))
{
File.Delete(tmpFile);
}
if (Directory.Exists(tmpDir))
{
Directory.Delete(tmpDir, true);
}
return(isOk);
}
private static VersionData ReadVersionData(XmlReader reader)
{
var result = new VersionData();
reader.ReadStartElement("VersionData");
reader.ReadStartElement("VersionNumberString");
result.VersionNumberString = reader.ReadContentAsString();
reader.ReadEndElement();
reader.ReadStartElement("Description");
if (reader.NodeType == XmlNodeType.Text)
{
result.Description = reader.ReadContentAsString();
reader.ReadEndElement();
}
if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "Description")
{
reader.ReadEndElement();
}
reader.ReadEndElement();
return(result);
}
private VersionData GetVersionData(PinnedBufferReader reader, ref UInt32 padding)
{
VersionData result = new VersionData();
padding = NativeMethods.AlignToInt(padding);
UInt32 length = padding;
result.Info = reader.BytesToStructure <WinNT.Resource.VarFileInfo>(ref padding);
String szKey = reader.BytesToStringUni(ref padding);
result.szKey = (VersionTableType)Enum.Parse(typeof(VersionTableType), szKey);
List <VersionTable> items = new List <VersionTable>();
while (padding - length < result.Info.wLength)
{
padding = NativeMethods.AlignToInt(padding);
items.Add(this.GetVersionTable(reader, result.szKey, ref padding));
padding = NativeMethods.AlignToInt(padding);
}
result.Items = items.ToArray();
return(result);
}
public void CreateUploadCommit(string[] pathArray, VersionData versionData)
{
var uploadFileObjectList = new List<UploadFileObject>();
var st = new StringBuilder();
st.Append("[Update Data] ");
foreach (var path in pathArray)
{
var fileName = Path.GetFileNameWithoutExtension(path);
var fileExtension = Path.GetExtension(path);
if (versionData.GetVersionValue(fileName) == null)
{
versionData.AddNewVerionData(fileName);
}
var fileVersionName = versionData.GetNextVersion(fileName);
var fileFullName = string.Format("{0}{1}", fileVersionName, fileExtension);
fileExtension = fileExtension.Replace(".", "");
var byteArray = File.ReadAllBytes(path);
var fullPath = string.Format("{0}/{1}/{2}/{3}", BaseDataPath, fileExtension, fileName, fileFullName);
uploadFileObjectList.Add(new UploadFileObject(fullPath, fileFullName, byteArray));
st.AppendFormat(" {0}, ", fileFullName);
}
CommitObjectList.Add(new CommitObject(st.ToString(), uploadFileObjectList));
}
public override async Task <VersionData> GetVersionFile(string[] fileArray, Action <string> updateLabel)
{
var versionData = new VersionData();
try
{
updateLabel?.Invoke("Get Repository..");
GetRepository = await Client.Repository.Get(OwnerSpaceName, RepositoryName);
updateLabel?.Invoke("Check Version Data..");
var existingFile = await Client.Repository.Content.GetAllContentsByRef(OwnerSpaceName, RepositoryName, VersionDataPath, ReferenceName);
var versionInfo = existingFile.First().Content;
versionData.AddVerionData(versionInfo);
}
catch (NotFoundException)
{
foreach (var path in fileArray)
{
var fileName = Path.GetFileNameWithoutExtension(path);
versionData.AddNewVerionData(fileName);
}
}
return(versionData);
}
public void Export(bool packingAll, bool release = false)
{
XTweenVersionController controller = XTweenVersionController.To;
VersionData data = controller.Data;
string addStr = "";
string exportRootPath = SystemUtil.AbsPath + "/Bin";
List <string> exportPathList = new List <string>(this._folderList.ToArray());
if (packingAll)
{
addStr = "All_";
exportRootPath = ExportDefaultPath;
exportPathList.Add("Assets/Toki/XAssets/XTween/Export");
exportPathList.Add("Assets/Toki/XAssets/XTween/Example");
exportPathList.Add("Assets/Toki/XAssets/XTween/Images");
exportPathList.Add("Assets/Toki/XAssets/XTween/Resources");
}
else
{
string version = this.ExportVersion;
data.version = version;
controller.Save();
}
string exportFileName = "XTween_" + addStr + data.version + ".unitypackage";
string exportPath = exportRootPath + "/" + exportFileName;
if (!release)
{
AssetDatabase.ExportPackage(exportPathList.ToArray(), exportPath, ExportPackageOptions.Interactive | ExportPackageOptions.Recurse);
}
}
// left more recent: 1
// identicals: 0
// right more recent: -1
public static int CompareVersion(VersionData left, VersionData right)
{
if (left.IsValidSemver != right.IsValidSemver)
{
return(left.IsValidSemver ? 1 : -1);
}
int compareLength = left.Length > right.Length ? left.Length : right.Length;
for (int i = 0; i < compareLength; ++i)
{
int leftNumber = left.GetIndex(i);
int rightNumber = right.GetIndex(i);
if (leftNumber > rightNumber)
{
return(1);
}
if (leftNumber < rightNumber)
{
return(-1);
}
}
return(0);
}
/// <summary>
/// Creates a file in the file directory from data
/// </summary>
/// <param name="directory">The directory which will contain the created file</param>
/// <param name="data">The VersionData to create the file</param>
public static void CreateVersionData(string directory, VersionData data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (!System.IO.Directory.Exists(directory))
{
throw new IOException("Directory " + directory + " does not exist");
}
string path = Path.Combine(directory, data.Filename);
if (data.Filetype == VersionData.FileType.Directory)
{
System.IO.Directory.CreateDirectory(path);
foreach (VersionData vd in data.Children)
{
CreateVersionData(path, vd);
}
}
else
{
using var fs = File.Create(path);
data.Data.CopyTo(fs);
}
}
public bool LoadLocalInfo(string localUrl)
{
bool isLoadSucess = false;
if (!File.Exists(localUrl))
{
LogMessage(MESSAGE_NORMALINFO, "没有找到本地版本信息,请与管理员联系!");
CallError();
}
else
{
VersionData data = null;
using (FileStream fs = new FileStream(Settings.LocalUrl, FileMode.Open, FileAccess.Read))
{
byte[] bytes = new byte[fs.Length];
string json = Encoding.UTF8.GetString(bytes);
data = JsonUtility.Decode <VersionData>(json);
}
if (data == null)
{
LogMessage(MESSAGE_NORMALINFO, "无法解析本地版本信息,请与管理员联系!");
CallError();
}
else
{
ThisVersion = new Version(data.Version);
LogMessage(MESSAGE_THISVERSION, ThisVersion.ToString());
isLoadSucess = true;
}
}
return(isLoadSucess);
}
public override async Task<VersionData> GetVersionFile(string[] fileArray, Action<string> updateLabel)
{
var versionData = new VersionData();
string responseString = string.Empty;
try
{
updateLabel?.Invoke("Get Master Branches..");
await RequestUpdateHash();
updateLabel?.Invoke("Check Version Data..");
responseString = await RequestFindFile(VersionDataPath);
}
catch (Exception e)
{
}
if (responseString == string.Empty)
{
foreach (var path in fileArray)
{
var fileName = Path.GetFileNameWithoutExtension(path);
versionData.AddNewVerionData(fileName);
}
}
else versionData.AddVerionData(responseString);
return versionData;
}
public void CreateVersion(string applicationName, int version)
{
if (!Auth.AllowCreateVersion(applicationName))
{
throw new SettingsAuthorizationException(AuthorizationScope.Version, AuthorizationLevel.Create, applicationName, Auth.CurrentIdentity.Id);
}
var application = GetApplicationsData(applicationName).SingleOrDefault();
if (application == null)
{
throw new SettingsNotFoundException(Constants.ERROR_APPLICATION_UNKNOWN);
}
var data = GetVersionData(application).SingleOrDefault(v => v.Version == version);
if (data != null)
{
throw new SettingsDuplicateException(Constants.ERROR_VERION_ALREADY_EXISTS);
}
data = new VersionData();
data.ApplicationId = application.Id;
data.Created = DateTime.UtcNow;
data.Version = version;
application.Versions.Add(data);
Store.Save();
}
public void CreateVersionCommit(VersionData versionData)
{
byte[] strByte = Encoding.UTF8.GetBytes(versionData.ToString());
var uploadFileObject = new UploadFileObject(VersionDataPath, "version.txt", strByte);
CommitObjectList.Add(new CommitObject("Update version", new List<UploadFileObject>() { uploadFileObject }));
}
/// <summary>
/// Loads the Version from the file directory, using VersionData.Hash as its hash
/// </summary>
/// <param name="filepath">The absolute path to this Version file</param>
/// <param name="directory">The directory from which to load dependencies</param>
/// <param name="loadData">Whether or not to read the files into VersionData</param>
/// <param name="changelog">An optional Changelog to load the hashes of VersionData</param>
/// <returns></returns>
public static Version LoadVersion(string filepath, DirectoryStructure directory, bool loadData,
Changelog changelog = null)
{
VersionData data = VersionDataFileManager.LoadTopLevelVD(filepath, "", loadData, directory, changelog);
return(new Version(data, data.Hash));
}
/// <summary>
/// Generates the version data.
/// </summary>
private void GenerateVersionData(ISonarConfiguration configuration)
{
var version = new VersionData();
version.DownloadPath = "/static/csharp/SonarLint.zip";
version.InstallPath = Path.Combine(this.roslynHomeDiagPath, "csharp", "lint");
this.InternalVersionsCsharp.Add(version);
version = new VersionData();
version.InstallPath = Path.Combine(this.roslynHomeDiagPath, "csharp", "analyser");
version.DownloadPath = "/static/csharp/SonarAnalyzer.zip";
this.InternalVersionsCsharp.Add(version);
var settings = this.rest.GetSettings(configuration);
version = new VersionData();
version.InstallPath = Path.Combine(this.roslynHomeDiagPath, "csharp", "analyser");
var result = settings.Where(x => x.key == "sonaranalyzer-cs.staticResourceName").FirstOrDefault();
if (result != null)
{
version.DownloadPath = "/static/csharp/" + result.Value;
this.InternalVersionsCsharp.Add(version);
}
}
public VersionDetails(string filepath, bool updateFields = true)
{
if (File.Exists(@filepath))
{
version = JsonConvert.DeserializeObject <VersionData>(File.ReadAllText(@filepath));
if (updateFields)
{
version.Server = System.Environment.MachineName;
foreach (VersionDataComponent component in version.Components)
{
foreach (VersionDataFileItem fileitem in component.Files)
{
if (File.Exists(fileitem.Path))
{
FileInfo fi = new FileInfo(fileitem.Path);
fileitem.Date = fi.LastWriteTime.ToShortDateString();
fileitem.Size = fi.Length.ToString();
fileitem.MD5 = FileMd5Hash(fileitem.Path);
}
else
{
fileitem.Date = fileitem.Size = fileitem.MD5 = "File not found";
}
}
}
}
}
else
{
// No existe fichero de versiones...
version = new VersionData();
version.Version = "";
}
}
/// <summary>
/// 游客登陆
/// </summary>
/// <param name="go"></param>
private void OnTourisLoginHandler(GameObject go)
{
//UIManager.CreateWin(UIName.LOGIN_INPUT_WIN);
if (ClientDefine.isWXLogin && !VersionData.IsReviewingVersion())
{
string md5Content = PlayerPrefs.GetString("accountServerLoginContent", "");
if (!string.IsNullOrEmpty(md5Content))
{
UtilTools.ShowWaitWin(WaitFlag.LoginWin);
LoginInputController.AccountServer_WXLogin(md5Content);
}
else
{
SDKManager.getInstance().CommonSDKInterface.login();
}
}
else
{
var ctrl = UIManager.GetControler <LoginInputController>();
StartCoroutine(ctrl.registerToAccountServerFast());
//UtilTools.ShowWaitWin(WaitFlag.LoginWin, 5f);
//快速登录
//LoginController.AccountServer_QuickLogin();
}
// ctrl.LoginTouris();
}
public Models.Version Version()
{
byte[] payload = PayloadFactory
.BuildGetVersionPayload(DateTime.Now.ToString());
string invocationResponse = Client.Invoke(payload);
System.Diagnostics.Debug.WriteLine("Version[invocationResponse]: " + invocationResponse);
JsonRpcResponse <VersionData> rpcResponse =
JsonConvert.DeserializeObject <JsonRpcResponse <VersionData> >(invocationResponse);
ThrowOnError(rpcResponse);
VersionData versions = rpcResponse.Result;
Models.Version version = new Models.Version
{
ClientVersion = new Models.ComponentVersion
{
Version = versions.ClientVersion.Version,
CommitHash = versions.ClientVersion.CommitHash,
SourceHash = versions.ClientVersion.SourceHash
},
SmaersVersion = new Models.ComponentVersion
{
Version = versions.SmaersVersion.Version,
CommitHash = versions.SmaersVersion.CommitHash,
SourceHash = versions.SmaersVersion.SourceHash
},
SdkVersion = Constants.SDK_VERSION
};
return(version);
}
//生成版本文件
public void CreatVersionFile()
{
Dictionary <string, SingleField> VersionData = ConfigManager.GetData(UpdateManager.versionFileName);
if (VersionData == null)
{
VersionData = new Dictionary <string, SingleField>();
}
if (VersionData.ContainsKey(UpdateManager.key_largeVersion))
{
VersionData[UpdateManager.key_largeVersion] = new SingleField(largeVersion);
}
else
{
VersionData.Add(UpdateManager.key_largeVersion, new SingleField(largeVersion));
}
if (VersionData.ContainsKey(UpdateManager.key_smallVerson))
{
VersionData[UpdateManager.key_smallVerson] = new SingleField(smallVersion);
}
else
{
VersionData.Add(UpdateManager.key_smallVerson, new SingleField(smallVersion));
}
ConfigManager.SaveData(UpdateManager.versionFileName, VersionData);
AssetDatabase.Refresh();
}
public PlanVersion(VersionData version)
{
_version = version;
_simulations = new List <Simulation>();
_actions = new List <Action>();
_resourceTypes = new List <ResourceType>();
}
/// <summary>
/// Loads version information from a JSON file.
/// </summary>
/// <param name="filename">The JSON file to load version information from.</param>
/// <returns><c>true</c> if successful.</returns>
public static bool Load(string filename)
{
if (!File.Exists(filename))
return false;
var contents = File.ReadAllText(filename);
_currentVersion = JsonConvert.DeserializeObject<VersionData>(contents);
return true;
}
public void LoadTable()
{
try
{
XmlElement root = AsTableBase.GetXmlRootElement( "Table/Version");
XmlNodeList nodes = root.ChildNodes;
foreach( XmlNode node in nodes)
{
VersionData data = new VersionData( node);
version = string.Format( "{0}.{1}{2}", AsGameDefine.BUNDLE_VERSION, data.version, AsNetworkDefine.ENVIRONMENT);
}
}
catch( System.Exception e)
{
Debug.LogError(e);
}
}
private static bool DownloadFileFromServer(ISonarConfiguration authentication, VersionData versionToUse, string tmpFile, string tmpDir)
{
try
{
var urldownload = authentication.Hostname + versionToUse.DownloadPath;
using (var client = new WebClient())
{
client.DownloadFile(urldownload, tmpFile);
ZipFile.ExtractToDirectory(tmpFile, tmpDir);
var files = Directory.GetFiles(tmpDir);
var versionDir = "";
foreach (var file in files)
{
if (string.IsNullOrEmpty(versionDir))
{
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(file);
string ver = fvi.FileVersion;
versionDir = Path.Combine(versionToUse.InstallPath, ver);
versionToUse.InstallPath = Path.Combine(versionToUse.InstallPath, ver);
if (!Directory.Exists(versionToUse.InstallPath))
{
Directory.CreateDirectory(versionToUse.InstallPath);
}
}
var endPath = Path.Combine(versionToUse.InstallPath, Path.GetFileName(file));
if (!File.Exists(endPath))
{
File.Copy(file, endPath, true);
}
}
}
return true;
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return false;
}
}
/// <summary>
/// Synchronizes the analysers from server.
/// </summary>
/// <param name="authentication">The authentication.</param>
/// <param name="versionToUse">The version to use.</param>
private bool SyncAnalysersFromServer(ISonarConfiguration authentication, VersionData versionToUse)
{
var tmpFile = Path.GetTempFileName();
var tmpDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
bool isOk = false;
if (File.Exists(tmpFile))
{
File.Delete(tmpFile);
}
try
{
isOk = DownloadFileFromServer(authentication, versionToUse, tmpFile, tmpDir);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
if (File.Exists(tmpFile))
{
File.Delete(tmpFile);
}
if (Directory.Exists(tmpDir))
{
Directory.Delete(tmpDir, true);
}
return isOk;
}
/// <summary>
/// Generates the version data.
/// </summary>
private void GenerateVersionData()
{
var version = new VersionData();
version.DownloadPath = "/static/csharp/SonarLint.zip";
version.InstallPath = Path.Combine(this.roslynHomeDiagPath, "csharp", "lint");
this.InternalVersionsCsharp.Add(version);
version = new VersionData();
version.InstallPath = Path.Combine(this.roslynHomeDiagPath, "csharp", "analyser");
version.DownloadPath = "/static/csharp/SonarAnalyzer.zip";
this.InternalVersionsCsharp.Add(version);
}
/// <summary>
/// Verify the version data information from server response results.
/// </summary>
/// <param name="versionData">The version data from server response results.</param>
/// <param name="operationName">The operation name for the server response results.</param>
private void VerifyVersionData(VersionData[] versionData, OperationName operationName)
{
bool areVersionsResultEqual = false;
string fileVersionsFromSUT = string.Empty;
// The file versions get from GetVersions response
VersionData[] fileVersionsFromGetVersions = null;
// If the VersionData are got from GetVersions operation, use SUT method GetFileVersions to
// verify the VersionData. Else use protocol method GetVersions to verify the VersionData.
if (operationName == OperationName.GetVersions)
{
fileVersionsFromSUT = this.sutControlAdapterInstance.GetFileVersions(this.documentLibrary, this.fileName);
this.site.Assert.AreNotEqual<string>(
string.Empty,
fileVersionsFromSUT,
"GetFileVersions operation returns {0}, the not empty value means the operation executed" +
" successfully and the empty value means the operation failed",
fileVersionsFromSUT);
// Verify that the result element returned from server using
// Protocol Adapter equals the result element returned from server using SUT Control Adapter.
areVersionsResultEqual = AdapterHelper.AreVersionsResultEqual(fileVersionsFromSUT, versionData);
}
else
{
// Get the relative filename of the file.
string docRelativeUrl = this.documentLibrary + "/" + this.fileName;
// Get the versions information from server.
GetVersionsResponseGetVersionsResult getVersionsResponse =
this.protocolAdapterInstance.GetVersions(docRelativeUrl);
fileVersionsFromGetVersions = getVersionsResponse.results.result;
// Verify that the result element returned from server equals
// the result element returned from GetVersions response.
areVersionsResultEqual = AdapterHelper.AreVersionsResultEqual(fileVersionsFromGetVersions, versionData);
}
// Verify MS-VERSS requirement: MS-VERSS_R48
this.site.CaptureRequirementIfIsTrue(
areVersionsResultEqual,
48,
@"[In Results] result: A separate result element MUST exist for each version of the file that the user can access.");
string responseVersionData = TransformVersionDataToString(versionData);
switch (operationName)
{
case OperationName.GetVersions:
// Add the debug information
this.site.Log.Add(
LogEntryKind.Debug,
"The actual response of GetVersions is {0} and the expected response of GetVersions is {1}",
responseVersionData,
fileVersionsFromSUT);
// Verify MS-VERSS requirement: MS-VERSS_R131
this.site.CaptureRequirementIfIsTrue(
areVersionsResultEqual,
131,
@"[In GetVersionsResponse] GetVersionsResult: An XML node that conforms to the structure specified in section 2.2.4.1 and that contains the details about all the versions of the specified file that the user can access.");
break;
case OperationName.DeleteVersion:
// Add the debug information
this.site.Log.Add(
LogEntryKind.Debug,
"The actual response of DeleteVersion is {0} and the expected response of DeleteVersion is {1}",
responseVersionData,
TransformVersionDataToString(fileVersionsFromGetVersions));
// Verify MS-VERSS requirement: MS-VERSS_R112
this.site.CaptureRequirementIfIsTrue(
areVersionsResultEqual,
112,
@"[In DeleteVersionResponse] DeleteVersionResult: An XML node that conforms to the structure specified in section 2.2.4.1 and that contains the details about all the versions of the specified file that the user can access.");
break;
case OperationName.RestoreVersion:
// Add the debug information
this.site.Log.Add(
LogEntryKind.Debug,
"The actual response of RestoreVersion is {0} and the expected response of RestoreVersion is {1}",
responseVersionData,
TransformVersionDataToString(fileVersionsFromGetVersions));
// Verify MS-VERSS requirement: MS-VERSS_R152
this.site.CaptureRequirementIfIsTrue(
areVersionsResultEqual,
152,
@"[In RestoreVersionResponse] RestoreVersionResult: MUST return an XML node that conforms to the structure specified in section 2.2.4.1, which contains the details about all the versions of the specified file that the user can access.");
break;
case OperationName.DeleteAllVersions:
// Add the debug information
this.site.Log.Add(
LogEntryKind.Debug,
"The actual response of DeleteAllVersions is {0} and the expected response of DeleteAllVersions is {1}",
responseVersionData,
TransformVersionDataToString(fileVersionsFromGetVersions));
// Verify MS-VERSS requirement: MS-VERSS_R92
this.site.CaptureRequirementIfIsTrue(
areVersionsResultEqual,
92,
@"[In DeleteAllVersionsResponse] DeleteAllVersionsResult: An XML node that conforms to the structure specified in section 2.2.4.1 and that contains the details about all the versions of the specified file that the user can access.");
break;
}
foreach (VersionData data in versionData)
{
string specifiedVersionFileInformation = string.Empty;
if (this.fileVersionAttributes.ContainsKey(data.version.Replace("@", string.Empty)) == false)
{
// Get data version information from server.
specifiedVersionFileInformation = this.sutControlAdapterInstance.GetFileVersionAttributes(
this.documentLibrary,
this.fileName,
data.version.Replace("@", string.Empty));
this.fileVersionAttributes.Add(data.version.Replace("@", string.Empty), specifiedVersionFileInformation);
}
else
{
specifiedVersionFileInformation = this.fileVersionAttributes[data.version.Replace("@", string.Empty)];
}
this.site.Assert.AreNotEqual<string>(
string.Empty,
specifiedVersionFileInformation,
"GetSpecifiedVersionFileInformation operation returns {0}, the non-empty value means the" +
" operation was executed successfully and the empty value means the operation failed",
specifiedVersionFileInformation);
string[] attributes = specifiedVersionFileInformation.Split(new string[] { "^" }, StringSplitOptions.None);
string expectedCreatedByName = attributes[0];
expectedCreatedByName = expectedCreatedByName.Substring(expectedCreatedByName.IndexOf("\\", System.StringComparison.CurrentCulture) + 1);
ulong expectedSize = ulong.Parse(attributes[1]);
// According to Open Specification section 2.2.4.3, the createdByName attribute is an optional attribute.
if (!string.IsNullOrEmpty(data.createdByName))
{
// Verify MS-VERSS requirement: MS-VERSS_R165
this.site.CaptureRequirementIfAreEqual<string>(
expectedCreatedByName.ToLower(System.Globalization.CultureInfo.CurrentCulture),
data.createdByName.Substring(data.createdByName.IndexOf("\\", System.StringComparison.CurrentCulture) + 1).ToLower(System.Globalization.CultureInfo.CurrentCulture),
165,
@"[In VersionData] createdByName: The display name of the creator of the version of the file.");
}
// Verify MS-VERSS requirement: MS-VERSS_R64
this.site.CaptureRequirementIfAreEqual<ulong>(
expectedSize,
data.size,
64,
@"[In VersionData] size: The size, in bytes, of the version of the file.");
}
}
/// <summary>
/// Verify the VersionData complex type related requirements
/// </summary>
/// <param name="versionDataArray">An array of VersionData object.</param>
/// <param name="isSchemaVerified">A Boolean value indicates whether the schema has been verified.</param>
private void VerifyVersionDataComplexType(VersionData[] versionDataArray, bool isSchemaVerified)
{
#region Verify MS-VERSS_R56
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-VERSS_R56");
// Verify MS-VERSS requirement: MS-VERSS_R56
Site.CaptureRequirementIfIsTrue(
isSchemaVerified,
56,
@"[In VersionData] The VersionData complex type specifies the details about a single version of a file.
<s:complexType name=""VersionData"">
<s:attribute name=""version"" type=""s:string"" use=""required"" />
<s:attribute name=""url"" type=""s:string"" use=""required"" />
<s:attribute name=""created"" type=""s:string"" use=""required"" />
<s:attribute name=""createdRaw"" type=""s:string"" use=""required"" />
<s:attribute name=""createdBy"" type=""s:string"" use=""required"" />
<s:attribute name=""createdByName"" type=""s:string"" use=""optional"" />
<s:attribute name=""size"" type=""s:unsignedLong"" use=""required"" />
<s:attribute name=""comments"" type=""s:string"" use=""required"" />
</s:complexType>");
#endregion
#region Verify MS-VERSS_R58
// According to MS-OFCGLOS,the current version is the latest version of a document.
// Then current version is the most recent version of the file.
// If the current version is preceded with an at sign (@),then R58 will be verified.
string currentVersion = AdapterHelper.GetCurrentVersion(versionDataArray);
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-VERSS_R58, the value of current version is {0}", currentVersion);
bool isR58Verified = currentVersion.StartsWith("@", System.StringComparison.CurrentCulture);
// Verify MS-VERSS requirement: MS-VERSS_R58
Site.CaptureRequirementIfIsTrue(
isR58Verified,
58,
@"[In VersionData] version: The most recent version of the file MUST be preceded with an at sign (@).");
#endregion
#region Verify MS-VERSS_R59
foreach (VersionData versionData in versionDataArray)
{
if (versionData.version != currentVersion)
{
float versionNumber;
bool isR59Verified = float.TryParse(versionData.version, out versionNumber);
// Add the debug information
Site.Log.Add(
LogEntryKind.Debug,
"Verify MS-VERSS_R59, the value of version is {0}",
versionData.version);
// Verify MS-VERSS requirement: MS-VERSS_R59
Site.CaptureRequirementIfIsTrue(
isR59Verified,
59,
@"[In VersionData] version: All the other versions MUST exist without any prefix. ");
}
}
#endregion
#region Verify MS-VERSS_R60101
foreach (VersionData versionData in versionDataArray)
{
System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@"^@?\d+\.\d+$");
bool isR60101Verified = regex.IsMatch(versionData.version);
if (Common.IsRequirementEnabled(60101, this.Site))
{
// Add the debug information
Site.Log.Add(
LogEntryKind.Debug,
"Verify MS-VERSS_R60101, the value of attribute version in VersionData is {0}",
versionData.version);
// Verify MS-VERSS requirement: MS-VERSS_R60101
Site.CaptureRequirementIfIsTrue(
isR60101Verified,
60101,
@"[In Appendix B: Product Behavior] Implementation does contain the version of the file, including the major version and minor version numbers connected by period, for example, ""1.0"". (Windows SharePoint Services 3.0 and above follow this behavior.)");
}
}
#endregion
#region Verify MS-VERSS_R61
foreach (VersionData versionData in versionDataArray)
{
System.Uri versionDataUrl = new System.Uri(versionData.url);
bool isR61Verified = AdapterHelper.ValidateAbsoluteUrlFormat(versionDataUrl);
// Add the debug information
Site.Log.Add(
LogEntryKind.Debug,
"Verify MS-VERSS_R61, the value of attribute URL in VersionData is {0}",
versionData.url);
// Verify MS-VERSS requirement: MS-VERSS_R61
Site.CaptureRequirementIfIsTrue(
isR61Verified,
61,
@"[In VersionData] url: The complete URL of the version of the file.");
}
#endregion
#region Verify MS-VERSS_R164
foreach (VersionData versionData in versionDataArray)
{
bool isR16401Enabled = Common.IsRequirementEnabled(16401, this.Site);
bool isR16402Enabled = Common.IsRequirementEnabled(16402, this.Site);
if (isR16401Enabled)
{
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-VERSS_R16401");
// Verify MS-VERSS requirement: MS-VERSS_R16401
Site.CaptureRequirementIfIsNotNull(
versionData.createdRaw,
16401,
@"[In Appendix B: Product Behavior] Implementation does return this attribute. [In VersionData] createdRaw: The creation date and time for the version of the file in Datetime format, as specified in [ISO-8601]. (Microsoft SharePoint Foundation 2010 and above follow this behavior.)");
}
if (isR16402Enabled)
{
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-VERSS_R16402");
// Verify MS-VERSS requirement: MS-VERSS_R16402
Site.CaptureRequirementIfIsNull(
versionData.createdRaw,
16402,
@"[In Appendix B: Product Behavior] Implementation does not return this attribute. [In VersionData] createdRaw: The creation date and time for the version of the file in Datetime format, as specified in [ISO-8601]. (<1> Section 2.2.4.3: Windows SharePoint Services 3.0 does not return this attribute.)");
}
}
#endregion
#region Verify MS-VERSS_R65
foreach (VersionData versionData in versionDataArray)
{
// Add the debug information
Site.Log.Add(
LogEntryKind.Debug,
"Verify MS-VERSS_R65, the value of attribute comments in VersionData is {0}",
versionData.comments);
// Verify MS-VERSS requirement: MS-VERSS_R65
Site.CaptureRequirementIfIsNotNull(
versionData.comments,
65,
@"[In VersionData] comments: The comment entered when the version of the file was replaced on the protocol server during check in.");
}
#endregion
}
/// <summary>
/// Get the version information from server response results.
/// </summary>
/// <param name="versionData">The version data from server response results.</param>
/// <returns>The version information in VersionData of response result.</returns>
private static string TransformVersionDataToString(VersionData[] versionData)
{
string responseVersionData = string.Empty;
bool firstCount = true;
foreach (VersionData data in versionData)
{
if (firstCount)
{
responseVersionData = data.version;
firstCount = false;
}
else
{
responseVersionData += "^" + data.version;
}
}
return responseVersionData;
}
