zydronium/websitepanel
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

merge commit

Browse source
This commit is contained in:
robvde 2015-04-08 16:43:22 +08:00
commit d2790fad11
213 changed files with 32903 additions and 1796 deletions
Download patch file Download diff file Expand all files Collapse all files

296
WebsitePanel/Database/update_db.sql
View file

@ -21,7 +21,10 @@ DELETE FROM HostingPlanQuotas WHERE QuotaID = 342
GO
DELETE FROM HostingPlanQuotas WHERE QuotaID = 343
GO
IF NOT EXISTS (SELECT * FROM [dbo].[ResourceGroups] WHERE GroupID = 33 AND [GroupName] = 'VPS2012')
BEGIN
DELETE FROM HostingPlanResources WHERE GroupID = 33
END
GO
@ -8218,6 +8221,27 @@ AS
INNER JOIN IPAddresses AS IP ON PIP.AddressID = IP.AddressID
INNER JOIN PackagesTreeCache AS PT ON PIP.PackageID = PT.PackageID
WHERE PT.ParentPackageID = @PackageID AND IP.PoolID = 3)
ELSE IF @QuotaID = 558 BEGIN -- RAM of VPS2012
DECLARE @Result1 int = (SELECT SUM(CAST(SIP.PropertyValue AS int)) FROM ServiceItemProperties AS SIP
INNER JOIN ServiceItems AS SI ON SIP.ItemID = SI.ItemID
INNER JOIN PackagesTreeCache AS PT ON SI.PackageID = PT.PackageID
WHERE SIP.PropertyName = 'RamSize' AND PT.ParentPackageID = @PackageID)
DECLARE @Result2 int = (SELECT SUM(CAST(SIP.PropertyValue AS int)) FROM ServiceItemProperties AS SIP
INNER JOIN ServiceItems AS SI ON SIP.ItemID = SI.ItemID
INNER JOIN PackagesTreeCache AS PT ON SI.PackageID = PT.PackageID
WHERE SIP.PropertyName = 'DynamicMemory.Maximum' AND PT.ParentPackageID = @PackageID)
SET @Result = CASE WHEN isnull(@Result1,0) > isnull(@Result2,0) THEN @Result1 ELSE @Result2 END
END
ELSE IF @QuotaID = 559 -- HDD of VPS2012
SET @Result = (SELECT SUM(CAST(SIP.PropertyValue AS int)) FROM ServiceItemProperties AS SIP
INNER JOIN ServiceItems AS SI ON SIP.ItemID = SI.ItemID
INNER JOIN PackagesTreeCache AS PT ON SI.PackageID = PT.PackageID
WHERE SIP.PropertyName = 'HddSize' AND PT.ParentPackageID = @PackageID)
ELSE IF @QuotaID = 562 -- External IP addresses of VPS2012
SET @Result = (SELECT COUNT(PIP.PackageAddressID) FROM PackageIPAddresses AS PIP
INNER JOIN IPAddresses AS IP ON PIP.AddressID = IP.AddressID
INNER JOIN PackagesTreeCache AS PT ON PIP.PackageID = PT.PackageID
WHERE PT.ParentPackageID = @PackageID AND IP.PoolID = 3)
ELSE IF @QuotaID = 100 -- Dedicated Web IP addresses
SET @Result = (SELECT COUNT(PIP.PackageAddressID) FROM PackageIPAddresses AS PIP
INNER JOIN IPAddresses AS IP ON PIP.AddressID = IP.AddressID
@ -8861,16 +8885,168 @@ RETURN
GO
-- Hyper-V 2012 R2 Provider
IF NOT EXISTS (SELECT * FROM [dbo].[ResourceGroups] WHERE [GroupName] = 'VPS2012')
BEGIN
INSERT [dbo].[ResourceGroups] ([GroupID], [GroupName], [GroupOrder], [GroupController], [ShowGroup]) VALUES (33, N'VPS2012', 19, NULL, 1)
INSERT [dbo].[ServiceItemTypes] ([ItemTypeID], [GroupID], [DisplayName], [TypeName], [TypeOrder], [CalculateDiskspace], [CalculateBandwidth], [Suspendable], [Disposable], [Searchable], [Importable], [Backupable]) VALUES (41, 33, N'VirtualMachine', N'WebsitePanel.Providers.Virtualization.VirtualMachine, WebsitePanel.Providers.Base', 1, 0, 0, 1, 1, 1, 0, 0)
INSERT [dbo].[ServiceItemTypes] ([ItemTypeID], [GroupID], [DisplayName], [TypeName], [TypeOrder], [CalculateDiskspace], [CalculateBandwidth], [Suspendable], [Disposable], [Searchable], [Importable], [Backupable]) VALUES (42, 33, N'VirtualSwitch', N'WebsitePanel.Providers.Virtualization.VirtualSwitch, WebsitePanel.Providers.Base', 2, 0, 0, 1, 1, 1, 0, 0)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (553, 33, 1, N'VPS2012.ServersNumber', N'Number of VPS', 2, 0, 41, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (554, 33, 2, N'VPS2012.ManagingAllowed', N'Allow user to create VPS', 1, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (555, 33, 3, N'VPS2012.CpuNumber', N'Number of CPU cores', 3, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (556, 33, 7, N'VPS2012.BootCdAllowed', N'Boot from CD allowed', 1, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (557, 33, 8, N'VPS2012.BootCdEnabled', N'Boot from CD', 1, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (558, 33, 4, N'VPS2012.Ram', N'RAM size, MB', 2, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (559, 33, 5, N'VPS2012.Hdd', N'Hard Drive size, GB', 2, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (560, 33, 6, N'VPS2012.DvdEnabled', N'DVD drive', 1, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (561, 33, 10, N'VPS2012.ExternalNetworkEnabled', N'External Network', 1, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (562, 33, 11, N'VPS2012.ExternalIPAddressesNumber', N'Number of External IP addresses', 2, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (563, 33, 13, N'VPS2012.PrivateNetworkEnabled', N'Private Network', 1, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (564, 33, 14, N'VPS2012.PrivateIPAddressesNumber', N'Number of Private IP addresses per VPS', 3, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (565, 33, 9, N'VPS2012.SnapshotsNumber', N'Number of Snaphots', 3, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (566, 33, 15, N'VPS2012.StartShutdownAllowed', N'Allow user to Start, Turn off and Shutdown VPS', 1, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (567, 33, 16, N'VPS2012.PauseResumeAllowed', N'Allow user to Pause, Resume VPS', 1, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (568, 33, 17, N'VPS2012.RebootAllowed', N'Allow user to Reboot VPS', 1, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (569, 33, 18, N'VPS2012.ResetAlowed', N'Allow user to Reset VPS', 1, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (570, 33, 19, N'VPS2012.ReinstallAllowed', N'Allow user to Re-install VPS', 1, 0, NULL, NULL)
INSERT [dbo].[Quotas] ([QuotaID], [GroupID], [QuotaOrder], [QuotaName], [QuotaDescription], [QuotaTypeID], [ServiceQuota], [ItemTypeID], [HideQuota]) VALUES (571, 33, 12, N'VPS2012.Bandwidth', N'Monthly bandwidth, GB', 2, 0, NULL, NULL)
END
GO
IF NOT EXISTS (SELECT * FROM [dbo].[Providers] WHERE [ProviderName] = 'HyperV2012R2')
BEGIN
INSERT [dbo].[Providers] ([ProviderID], [GroupID], [ProviderName], [DisplayName], [ProviderType], [EditorControl], [DisableAutoDiscovery]) VALUES (350, 30, N'HyperV2012R2', N'Microsoft Hyper-V 2012 R2', N'WebsitePanel.Providers.Virtualization.HyperV2012R2, WebsitePanel.Providers.Virtualization.HyperV2012R2', N'HyperV2012R2', 1)
INSERT [dbo].[Providers] ([ProviderID], [GroupID], [ProviderName], [DisplayName], [ProviderType], [EditorControl], [DisableAutoDiscovery]) VALUES (350, 33, N'HyperV2012R2', N'Microsoft Hyper-V 2012 R2', N'WebsitePanel.Providers.Virtualization.HyperV2012R2, WebsitePanel.Providers.Virtualization.HyperV2012R2', N'HyperV2012R2', 1)
END
ELSE
BEGIN
UPDATE [dbo].[Providers] SET [EditorControl] = N'HyperV2012R2' WHERE [ProviderName] = 'HyperV2012R2'
UPDATE [dbo].[Providers] SET [EditorControl] = N'HyperV2012R2', [GroupID] = 33 WHERE [ProviderName] = 'HyperV2012R2'
END
GO
IF EXISTS (SELECT * FROM SYS.OBJECTS WHERE type = 'P' AND name = 'GetVirtualMachinesPaged2012')
DROP PROCEDURE GetVirtualMachinesPaged2012
GO
CREATE PROCEDURE [dbo].[GetVirtualMachinesPaged2012]
(
@ActorID int,
@PackageID int,
@FilterColumn nvarchar(50) = '',
@FilterValue nvarchar(50) = '',
@SortColumn nvarchar(50),
@StartRow int,
@MaximumRows int,
@Recursive bit
)
AS
-- check rights
IF dbo.CheckActorPackageRights(@ActorID, @PackageID) = 0
RAISERROR('You are not allowed to access this package', 16, 1)
-- start
DECLARE @condition nvarchar(700)
SET @condition = '
SI.ItemTypeID = 41 -- VPS2012
AND ((@Recursive = 0 AND P.PackageID = @PackageID)
OR (@Recursive = 1 AND dbo.CheckPackageParent(@PackageID, P.PackageID) = 1))
'
IF @FilterColumn <> '' AND @FilterColumn IS NOT NULL
AND @FilterValue <> '' AND @FilterValue IS NOT NULL
SET @condition = @condition + ' AND ' + @FilterColumn + ' LIKE ''' + @FilterValue + ''''
IF @SortColumn IS NULL OR @SortColumn = ''
SET @SortColumn = 'SI.ItemName ASC'
DECLARE @sql nvarchar(3500)
set @sql = '
SELECT COUNT(SI.ItemID) FROM Packages AS P
INNER JOIN ServiceItems AS SI ON P.PackageID = SI.PackageID
INNER JOIN Users AS U ON P.UserID = U.UserID
LEFT OUTER JOIN (
SELECT PIP.ItemID, IP.ExternalIP FROM PackageIPAddresses AS PIP
INNER JOIN IPAddresses AS IP ON PIP.AddressID = IP.AddressID
WHERE PIP.IsPrimary = 1 AND IP.PoolID = 3 -- external IP addresses
) AS EIP ON SI.ItemID = EIP.ItemID
LEFT OUTER JOIN PrivateIPAddresses AS PIP ON PIP.ItemID = SI.ItemID AND PIP.IsPrimary = 1
WHERE ' + @condition + '
DECLARE @Items AS TABLE
(
ItemID int
);
WITH TempItems AS (
SELECT ROW_NUMBER() OVER (ORDER BY ' + @SortColumn + ') as Row,
SI.ItemID
FROM Packages AS P
INNER JOIN ServiceItems AS SI ON P.PackageID = SI.PackageID
INNER JOIN Users AS U ON P.UserID = U.UserID
LEFT OUTER JOIN (
SELECT PIP.ItemID, IP.ExternalIP FROM PackageIPAddresses AS PIP
INNER JOIN IPAddresses AS IP ON PIP.AddressID = IP.AddressID
WHERE PIP.IsPrimary = 1 AND IP.PoolID = 3 -- external IP addresses
) AS EIP ON SI.ItemID = EIP.ItemID
LEFT OUTER JOIN PrivateIPAddresses AS PIP ON PIP.ItemID = SI.ItemID AND PIP.IsPrimary = 1
WHERE ' + @condition + '
)
INSERT INTO @Items
SELECT ItemID FROM TempItems
WHERE TempItems.Row BETWEEN @StartRow + 1 and @StartRow + @MaximumRows
SELECT
SI.ItemID,
SI.ItemName,
SI.PackageID,
P.PackageName,
P.UserID,
U.Username,
EIP.ExternalIP,
PIP.IPAddress
FROM @Items AS TSI
INNER JOIN ServiceItems AS SI ON TSI.ItemID = SI.ItemID
INNER JOIN Packages AS P ON SI.PackageID = P.PackageID
INNER JOIN Users AS U ON P.UserID = U.UserID
LEFT OUTER JOIN (
SELECT PIP.ItemID, IP.ExternalIP FROM PackageIPAddresses AS PIP
INNER JOIN IPAddresses AS IP ON PIP.AddressID = IP.AddressID
WHERE PIP.IsPrimary = 1 AND IP.PoolID = 3 -- external IP addresses
) AS EIP ON SI.ItemID = EIP.ItemID
LEFT OUTER JOIN PrivateIPAddresses AS PIP ON PIP.ItemID = SI.ItemID AND PIP.IsPrimary = 1
'
--print @sql
exec sp_executesql @sql, N'@PackageID int, @StartRow int, @MaximumRows int, @Recursive bit',
@PackageID, @StartRow, @MaximumRows, @Recursive
RETURN
GO
--ES OWA Editing
IF NOT EXISTS (SELECT * FROM SYS.TABLES WHERE name = 'EnterpriseFoldersOwaPermissions')
CREATE TABLE EnterpriseFoldersOwaPermissions
@ -9504,5 +9680,121 @@ END
GO
ALTER PROCEDURE [dbo].[AddServiceItem]
(
@ActorID int,
@PackageID int,
@ServiceID int,
@ItemName nvarchar(500),
@ItemTypeName nvarchar(200),
@ItemID int OUTPUT,
@XmlProperties ntext,
@CreatedDate datetime
)
AS
BEGIN TRAN
-- check rights
IF dbo.CheckActorPackageRights(@ActorID, @PackageID) = 0
RAISERROR('You are not allowed to access this package', 16, 1)
-- get GroupID
DECLARE @GroupID int
SELECT
@GroupID = PROV.GroupID
FROM Services AS S
INNER JOIN Providers AS PROV ON S.ProviderID = PROV.ProviderID
WHERE S.ServiceID = @ServiceID
DECLARE @ItemTypeID int
SELECT @ItemTypeID = ItemTypeID FROM ServiceItemTypes
WHERE TypeName = @ItemTypeName
AND ((@GroupID IS NULL) OR (@GroupID IS NOT NULL AND GroupID = @GroupID))
-- Fix to allow plans assigned to serveradmin
IF (@ItemTypeName = 'WebsitePanel.Providers.HostedSolution.Organization, WebsitePanel.Providers.Base')
BEGIN
IF NOT EXISTS (SELECT * FROM ServiceItems WHERE PackageID = 1)
BEGIN
INSERT INTO ServiceItems (PackageID, ItemTypeID,ServiceID,ItemName,CreatedDate)
VALUES(1, @ItemTypeID, @ServiceID, 'System', @CreatedDate)
DECLARE @TempItemID int
SET @TempItemID = SCOPE_IDENTITY()
INSERT INTO ExchangeOrganizations (ItemID, OrganizationID)
VALUES(@TempItemID, 'System')
END
END
-- add item
INSERT INTO ServiceItems
(
PackageID,
ServiceID,
ItemName,
ItemTypeID,
CreatedDate
)
VALUES
(
@PackageID,
@ServiceID,
@ItemName,
@ItemTypeID,
@CreatedDate
)
SET @ItemID = SCOPE_IDENTITY()
DECLARE @idoc int
--Create an internal representation of the XML document.
EXEC sp_xml_preparedocument @idoc OUTPUT, @XmlProperties
-- Execute a SELECT statement that uses the OPENXML rowset provider.
DELETE FROM ServiceItemProperties
WHERE ItemID = @ItemID
CREATE TABLE #TempTable(
ItemID int,
PropertyName nvarchar(50),
PropertyValue nvarchar(3000))
INSERT INTO #TempTable (ItemID, PropertyName, PropertyValue)
SELECT
@ItemID,
PropertyName,
PropertyValue
FROM OPENXML(@idoc, '/properties/property',1) WITH
(
PropertyName nvarchar(50) '@name',
PropertyValue nvarchar(3000) '@value'
) as PV
-- Move data from temp table to real table
INSERT INTO ServiceItemProperties
(
ItemID,
PropertyName,
PropertyValue
)
SELECT
ItemID,
PropertyName,
PropertyValue
FROM #TempTable
DROP TABLE #TempTable
-- remove document
exec sp_xml_removedocument @idoc
COMMIT TRAN
RETURN
GO
UPDATE [dbo].[ServiceItemTypes] SET TypeName ='WebsitePanel.Providers.SharePoint.SharePointEnterpriseSiteCollection, WebsitePanel.Providers.Base' WHERE DisplayName = 'SharePointEnterpriseSiteCollection'
GO

1
WebsitePanel/Sources/WebsitePanel.EnterpriseServer.Base/Packages/PackageSettings.cs
View file

@ -44,6 +44,7 @@ namespace WebsitePanel.EnterpriseServer
public const string EXCHANGE_SERVER = "ExchangeServer";
public const string HOSTED_SOLLUTION = "HostedSollution";
public const string VIRTUAL_PRIVATE_SERVERS = "VirtualPrivateServers";
public const string VIRTUAL_PRIVATE_SERVERS_2012 = "VirtualPrivateServers2012";
public const string VIRTUAL_PRIVATE_SERVERS_FOR_PRIVATE_CLOUD = "VirtualPrivateServersForPrivateCloud";
public int PackageId;

20
WebsitePanel/Sources/WebsitePanel.EnterpriseServer.Base/Packages/Quotas.cs
View file

@ -204,6 +204,26 @@ order by rg.groupOrder
public const string VPS_REINSTALL_ALLOWED = "VPS.ReinstallAllowed"; // Allow user to Re-install VPS
public const string VPS_BANDWIDTH = "VPS.Bandwidth"; // Monthly bandwidth, GB
public const string VPS2012_SERVERS_NUMBER = "VPS2012.ServersNumber"; // Number of VPS
public const string VPS2012_MANAGING_ALLOWED = "VPS2012.ManagingAllowed"; // Allow user to create VPS
public const string VPS2012_CPU_NUMBER = "VPS2012.CpuNumber"; // Number of CPU cores
public const string VPS2012_BOOT_CD_ALLOWED = "VPS2012.BootCdAllowed"; // Boot from CD allowed
public const string VPS2012_BOOT_CD_ENABLED = "VPS2012.BootCdEnabled"; // Boot from CD
public const string VPS2012_RAM = "VPS2012.Ram"; // RAM size, MB
public const string VPS2012_HDD = "VPS2012.Hdd"; // Hard Drive size, GB
public const string VPS2012_DVD_ENABLED = "VPS2012.DvdEnabled"; // DVD drive
public const string VPS2012_EXTERNAL_NETWORK_ENABLED = "VPS2012.ExternalNetworkEnabled"; // External Network
public const string VPS2012_EXTERNAL_IP_ADDRESSES_NUMBER = "VPS2012.ExternalIPAddressesNumber"; // Number of External IP addresses
public const string VPS2012_PRIVATE_NETWORK_ENABLED = "VPS2012.PrivateNetworkEnabled"; // Private Network
public const string VPS2012_PRIVATE_IP_ADDRESSES_NUMBER = "VPS2012.PrivateIPAddressesNumber"; // Number of Private IP addresses per VPS
public const string VPS2012_SNAPSHOTS_NUMBER = "VPS2012.SnapshotsNumber"; // Number of Snaphots
public const string VPS2012_START_SHUTDOWN_ALLOWED = "VPS2012.StartShutdownAllowed"; // Allow user to Start, Turn off and Shutdown VPS
public const string VPS2012_PAUSE_RESUME_ALLOWED = "VPS2012.PauseResumeAllowed"; // Allow user to Pause, Resume VPS
public const string VPS2012_REBOOT_ALLOWED = "VPS2012.RebootAllowed"; // Allow user to Reboot VPS
public const string VPS2012_RESET_ALOWED = "VPS2012.ResetAlowed"; // Allow user to Reset VPS
public const string VPS2012_REINSTALL_ALLOWED = "VPS2012.ReinstallAllowed"; // Allow user to Re-install VPS
public const string VPS2012_BANDWIDTH = "VPS2012.Bandwidth"; // Monthly bandwidth, GB
public const string VPSForPC_SERVERS_NUMBER = "VPSForPC.ServersNumber"; // Number of VPS
public const string VPSForPC_MANAGING_ALLOWED = "VPSForPC.ManagingAllowed"; // Allow user to create VPS
public const string VPSForPC_CPU_NUMBER = "VPSForPC.CpuNumber"; // Number of CPU cores

1
WebsitePanel/Sources/WebsitePanel.EnterpriseServer.Base/Servers/ResourceGroups.cs
View file

@ -52,6 +52,7 @@ namespace WebsitePanel.EnterpriseServer
public const string HostedCRM = "Hosted CRM"; // CRM 4/2011
public const string HostedCRM2013 = "Hosted CRM2013"; // CRM 2013/2015
public const string VPS = "VPS";
public const string VPS2012 = "VPS2012";
public const string BlackBerry = "BlackBerry";
public const string OCS = "OCS";
public const string VPSForPC = "VPSForPC";

1
WebsitePanel/Sources/WebsitePanel.EnterpriseServer.Base/Virtualization/VirtualizationErrorCodes.cs
View file

@ -39,6 +39,7 @@
public const string QUOTA_EXCEEDED_CPU = "VPS_QUOTA_EXCEEDED_CPU";
public const string QUOTA_EXCEEDED_RAM = "VPS_QUOTA_EXCEEDED_RAM";
public const string QUOTA_WRONG_RAM = "VPS_QUOTA_WRONG_RAM";
public const string QUOTA_NOT_IN_DYNAMIC_RAM = "VPS_QUOTA_NOT_IN_DYNAMIC_RAM";
public const string QUOTA_EXCEEDED_HDD = "VPS_QUOTA_EXCEEDED_HDD";
public const string QUOTA_WRONG_HDD = "VPS_QUOTA_WRONG_HDD";
public const string QUOTA_EXCEEDED_SNAPSHOTS = "VPS_QUOTA_EXCEEDED_SNAPSHOTS";

2858
WebsitePanel/Sources/WebsitePanel.EnterpriseServer.Client/VirtualizationServerProxy.cs
View file

File diff suppressed because it is too large Load diff

4559
WebsitePanel/Sources/WebsitePanel.EnterpriseServer.Client/VirtualizationServerProxy2012.cs Normal file
View file

File diff suppressed because it is too large Load diff

1
WebsitePanel/Sources/WebsitePanel.EnterpriseServer.Client/WebsitePanel.EnterpriseServer.Client.csproj
View file

@ -92,6 +92,7 @@
<Compile Include="HostedSharePointServersEntProxy.cs" />
<Compile Include="LyncProxy.cs" />
<Compile Include="RemoteDesktopServicesProxy.cs" />
<Compile Include="VirtualizationServerProxy2012.cs" />
<Compile Include="VirtualizationServerProxyForPrivateCloud.cs" />
<Compile Include="CRMProxy.cs" />
<Compile Include="DatabaseServersProxy.cs" />

113
WebsitePanel/Sources/WebsitePanel.EnterpriseServer.Code/Common/ObjectUtils.cs
View file

@ -98,6 +98,19 @@ namespace WebsitePanel.EnterpriseServer
svals[i] = ivals[i].ToString();
s = String.Join(";", svals);
}
// when property is custom class with Persistent attribute
else if (prop.PropertyType.GetCustomAttributes(typeof(PersistentAttribute), false).Length > 0)
{
// add sub-class properties to hash
var childHash = GetObjectProperties(val, persistentOnly);
foreach (var hashKey in childHash.Keys)
{
var value = childHash[hashKey];
hash.Add(prop.Name + "." + hashKey, value);
}
// exit
continue;
}
else
s = val.ToString();
}
@ -476,6 +489,41 @@ namespace WebsitePanel.EnterpriseServer
}
}
private static Hashtable GetPropertiesForCache(Type type, bool persistentOnly)
{
// create properties cache
var props = new Hashtable();
PropertyInfo[] objProps = type.GetProperties(BindingFlags.Instance
//| BindingFlags.DeclaredOnly
| BindingFlags.Public);
foreach (PropertyInfo prop in objProps)
{
// check for persistent attribute
object[] attrs = prop.GetCustomAttributes(typeof(PersistentAttribute), false);
if (!persistentOnly || (persistentOnly && attrs.Length > 0) && !props.ContainsKey(prop.Name))
{
// when property is custom class with Persistent attribute
if (prop.PropertyType.GetCustomAttributes(typeof (PersistentAttribute), false).Length > 0)
{
// add sub-class properties to hash
var childHash = GetPropertiesForCache(prop.PropertyType, persistentOnly);
foreach (var hashKey in childHash.Keys)
{
var value = childHash[hashKey];
props.Add(prop.Name + "." + hashKey, value);
}
// exit
continue;
}
// add property to hash
props.Add(prop.Name, prop);
}
}
return props;
}
public static void CreateObjectFromHash(object obj, Hashtable propValues, bool persistentOnly)
{
Type type = obj.GetType();
@ -489,21 +537,7 @@ namespace WebsitePanel.EnterpriseServer
}
else
{
// create properties cache
props = new Hashtable();
PropertyInfo[] objProps = type.GetProperties(BindingFlags.Instance
//| BindingFlags.DeclaredOnly
| BindingFlags.Public);
foreach (PropertyInfo prop in objProps)
{
// check for persistent attribute
object[] attrs = prop.GetCustomAttributes(typeof(PersistentAttribute), false);
if (!persistentOnly || (persistentOnly && attrs.Length > 0) && !props.ContainsKey(prop.Name))
{
// add property to hash
props.Add(prop.Name, prop);
}
}
props = GetPropertiesForCache(type, persistentOnly);
if (!propertiesCache.ContainsKey(type.Name))
{
@ -518,38 +552,63 @@ namespace WebsitePanel.EnterpriseServer
// try to locate specified property
if (props[propName] != null)
{
PropertyInfo prop = (PropertyInfo)props[propName];
string val = propValues[propName].ToString();
var currentObj = obj;
// when property is custom class with Persistent attribute
if (propName.Contains("."))
{
var mainPropertyName = propName.Split('.')[0];
var childPropertyName = propName.Split('.')[1];
var mainProperty = type.GetProperty(mainPropertyName);
if (mainProperty == null) continue;
var mainVal = mainProperty.GetValue(obj, null);
if (mainVal == null)
{
mainVal = Activator.CreateInstance(mainProperty.PropertyType);
mainProperty.SetValue(obj, mainVal, null);
}
currentObj = mainVal;
var childProperty = mainProperty.PropertyType.GetProperty(childPropertyName);
if (childProperty == null) continue;
prop = childProperty;
}
// set property
// we support:
// String
// Int32
// Boolean
// Float
PropertyInfo prop = (PropertyInfo)props[propName];
string val = propValues[propName].ToString();
if (prop.PropertyType == typeof(String))
prop.SetValue(obj, val, null);
prop.SetValue(currentObj, val, null);
else if (prop.PropertyType == typeof(Int32))
prop.SetValue(obj, Int32.Parse(val), null);
prop.SetValue(currentObj, Int32.Parse(val), null);
else
if (prop.PropertyType == typeof(long))
prop.SetValue(obj, long.Parse(val), null);
prop.SetValue(currentObj, long.Parse(val), null);
else
if (prop.PropertyType == typeof(Boolean))
prop.SetValue(obj, Boolean.Parse(val), null);
prop.SetValue(currentObj, Boolean.Parse(val), null);
else if (prop.PropertyType == typeof(Single))
prop.SetValue(obj, Single.Parse(val), null);
prop.SetValue(currentObj, Single.Parse(val), null);
else if (prop.PropertyType.IsEnum)
prop.SetValue(obj, Enum.Parse(prop.PropertyType, val, true), null);
prop.SetValue(currentObj, Enum.Parse(prop.PropertyType, val, true), null);
else
if (prop.PropertyType == typeof(Guid))
prop.SetValue(obj, new Guid(val), null);
prop.SetValue(currentObj, new Guid(val), null);
else
if (prop.PropertyType == typeof(string[]))
{
if (val == "")
prop.SetValue(obj, new string[0], null);
prop.SetValue(currentObj, new string[0], null);
else
prop.SetValue(obj, val.Split(';'), null);
prop.SetValue(currentObj, val.Split(';'), null);
}
else if (prop.PropertyType == typeof(int[]))
{
@ -562,7 +621,7 @@ namespace WebsitePanel.EnterpriseServer
if (val == "")
ivals = new int[0];
prop.SetValue(obj, ivals, null);
prop.SetValue(currentObj, ivals, null);
}
}
}

15
WebsitePanel/Sources/WebsitePanel.EnterpriseServer.Code/Data/DataProvider.cs
View file

@ -3456,6 +3456,21 @@ namespace WebsitePanel.EnterpriseServer
new SqlParameter("@Recursive", recursive));
return reader;
}
public static IDataReader GetVirtualMachinesPaged2012(int actorId, int packageId, string filterColumn, string filterValue,
string sortColumn, int startRow, int maximumRows, bool recursive)
{
IDataReader reader = SqlHelper.ExecuteReader(ConnectionString, CommandType.StoredProcedure,
"GetVirtualMachinesPaged2012",
new SqlParameter("@ActorID", actorId),
new SqlParameter("@PackageID", packageId),
new SqlParameter("@FilterColumn", VerifyColumnName(filterColumn)),
new SqlParameter("@FilterValue", VerifyColumnValue(filterValue)),
new SqlParameter("@SortColumn", VerifyColumnName(sortColumn)),
new SqlParameter("@StartRow", startRow),
new SqlParameter("@MaximumRows", maximumRows),
new SqlParameter("@Recursive", recursive));
return reader;
}
#endregion
public static IDataReader GetVirtualMachinesForPCPaged(int actorId, int packageId, string filterColumn, string filterValue,

18
WebsitePanel/Sources/WebsitePanel.EnterpriseServer.Code/Packages/PackageController.cs
View file

@ -488,6 +488,7 @@ namespace WebsitePanel.EnterpriseServer
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.MySql5, domain, "");
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.Statistics, domain, "");
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.VPS, domain, "");
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.VPS2012, domain, "");
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.VPSForPC, domain, "");
}
}
@ -711,6 +712,11 @@ namespace WebsitePanel.EnterpriseServer
if (Utils.ParseBool(vpsSettings["AutoAssignExternalIP"], true))
ServerController.AllocateMaximumPackageIPAddresses(packageId, ResourceGroups.VPS, IPAddressPool.VpsExternalNetwork);
// allocate "VPS" IP addresses
int vps2012ServiceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.VPS2012);
StringDictionary vps2012Settings = ServerController.GetServiceSettings(vps2012ServiceId);
if (Utils.ParseBool(vps2012Settings["AutoAssignExternalIP"], true))
ServerController.AllocateMaximumPackageIPAddresses(packageId, ResourceGroups.VPS2012, IPAddressPool.VpsExternalNetwork);
// allocate "VPSForPC" IP addresses
int vpsfcpServiceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.VPSForPC);
@ -1681,6 +1687,18 @@ namespace WebsitePanel.EnterpriseServer
}
}
// VPS2012
else if (String.Compare(PackageSettings.VIRTUAL_PRIVATE_SERVERS_2012, settingsName, true) == 0)
{
// load Exchange service settings
int vpsServiceId = GetPackageServiceId(packageId, ResourceGroups.VPS2012);
if (vpsServiceId > 0)
{
StringDictionary vpsSettings = ServerController.GetServiceSettings(vpsServiceId);
settings["HostnamePattern"] = vpsSettings["HostnamePattern"];
}
}
//vpforCP
else if (String.Compare(PackageSettings.VIRTUAL_PRIVATE_SERVERS_FOR_PRIVATE_CLOUD, settingsName, true) == 0)
{

6
WebsitePanel/Sources/WebsitePanel.EnterpriseServer.Code/Servers/ServerController.cs
View file

@ -1481,6 +1481,10 @@ namespace WebsitePanel.EnterpriseServer
{
return Quotas.VPS_EXTERNAL_IP_ADDRESSES_NUMBER;
}
else if (String.Compare(groupName, ResourceGroups.VPS2012, true) == 0)
{
return Quotas.VPS2012_EXTERNAL_IP_ADDRESSES_NUMBER;
}
else if (String.Compare(groupName, ResourceGroups.VPSForPC, true) == 0)
{
return Quotas.VPSForPC_EXTERNAL_IP_ADDRESSES_NUMBER;
@ -1840,6 +1844,7 @@ namespace WebsitePanel.EnterpriseServer
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.MySql5, domain, "");
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.Statistics, domain, "");
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.VPS, domain, "");
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.VPS2012, domain, "");
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.VPSForPC, domain, "");
}
@ -2403,6 +2408,7 @@ namespace WebsitePanel.EnterpriseServer
ServerController.AddServiceDNSRecords(domain.PackageId, ResourceGroups.MySql5, domain, "");
ServerController.AddServiceDNSRecords(domain.PackageId, ResourceGroups.Statistics, domain, "");
ServerController.AddServiceDNSRecords(domain.PackageId, ResourceGroups.VPS, domain, "");
ServerController.AddServiceDNSRecords(domain.PackageId, ResourceGroups.VPS2012, domain, "");
ServerController.AddServiceDNSRecords(domain.PackageId, ResourceGroups.VPSForPC, domain, "");
ServerController.AddServiceDNSRecords(domain.PackageId, ResourceGroups.Dns, domain, "");
break;

85
WebsitePanel/Sources/WebsitePanel.EnterpriseServer.Code/Virtualization2012/CreateServerAsyncWorker2012.cs Normal file
View file

@ -0,0 +1,85 @@
// Copyright (c) 2015, Outercurve Foundation.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// - Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// - Neither the name of the Outercurve Foundation nor the names of its
// contributors may be used to endorse or promote products derived from this
// software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using System;
using System.Collections.Generic;
using System.Web;
using System.Threading;
using WebsitePanel.Providers.Virtualization;
namespace WebsitePanel.EnterpriseServer
{
public class CreateServerAsyncWorker2012
{
#region Properties
public int ThreadUserId { get; set; }
public string TaskId { get; set; }
public VirtualMachine Item { get; set; }
public LibraryItem OsTemplate { get; set; }
public int ExternalAddressesNumber { get; set; }
public bool RandomExternalAddresses { get; set; }
public int[] ExternalAddresses { get; set; }
public int PrivateAddressesNumber { get; set; }
public bool RandomPrivateAddresses { get; set; }
public string[] PrivateAddresses { get; set; }
public string SummaryLetterEmail { get; set; }
#endregion
public CreateServerAsyncWorker2012()
{
ThreadUserId = -1; // admin
}
#region Create
public void CreateAsync()
{
// start asynchronously
Thread t = new Thread(new ThreadStart(Create));
t.Start();
}
private void Create()
{
// impersonate thread
if (ThreadUserId != -1)
SecurityContext.SetThreadPrincipal(ThreadUserId);
// perform backup
VirtualizationServerController2012.CreateVirtualMachineInternal(TaskId, Item, OsTemplate,
ExternalAddressesNumber, RandomExternalAddresses, ExternalAddresses,
PrivateAddressesNumber, RandomPrivateAddresses, PrivateAddresses,
SummaryLetterEmail);
}
#endregion
}
}

3719
WebsitePanel/Sources/WebsitePanel.EnterpriseServer.Code/Virtualization2012/VirtualizationServerController2012.cs Normal file
View file

File diff suppressed because it is too large Load diff

2
WebsitePanel/Sources/WebsitePanel.EnterpriseServer.Code/WebsitePanel.EnterpriseServer.Code.csproj
View file

@ -174,6 +174,8 @@
<Compile Include="Tasks\TaskManager.cs" />
<Compile Include="Users\UserAsyncWorker.cs" />
<Compile Include="Users\UserController.cs" />
<Compile Include="Virtualization2012\CreateServerAsyncWorker2012.cs" />
<Compile Include="Virtualization2012\VirtualizationServerController2012.cs" />
<Compile Include="VirtualizationForPrivateCloud\CreateAsyncVMfromVM.cs" />
<Compile Include="VirtualizationForPrivateCloud\CreateServerAsyncWorkerForPrivateCloud.cs" />
<Compile Include="VirtualizationForPrivateCloud\VirtualizationServerControllerForPrivateCloud.cs" />

5
WebsitePanel/Sources/WebsitePanel.EnterpriseServer/WebsitePanel.EnterpriseServer.csproj
View file

@ -127,6 +127,7 @@
<Content Include="esRemoteDesktopServices.asmx" />
<Content Include="esHeliconZoo.asmx" />
<Content Include="esLync.asmx" />
<Content Include="esVirtualizationServer2012.asmx" />
<Content Include="esVirtualizationServerForPrivateCloud.asmx" />
<Content Include="Default.aspx" />
<Content Include="ecStorefront.asmx" />
@ -184,6 +185,10 @@
<DependentUpon>esLync.asmx</DependentUpon>
<SubType>Component</SubType>
</Compile>
<Compile Include="esVirtualizationServer2012.asmx.cs">
<DependentUpon>esVirtualizationServer2012.asmx</DependentUpon>
<SubType>Component</SubType>
</Compile>
<Compile Include="esVirtualizationServerForPrivateCloud.asmx.cs">
<DependentUpon>esVirtualizationServerForPrivateCloud.asmx</DependentUpon>
<SubType>Component</SubType>

1
WebsitePanel/Sources/WebsitePanel.EnterpriseServer/esVirtualizationServer2012.asmx Normal file
View file

@ -0,0 +1 @@
<%@ WebService Language="C#" CodeBehind="esVirtualizationServer2012.asmx.cs" Class="WebsitePanel.EnterpriseServer.esVirtualizationServer2012" %>

476
WebsitePanel/Sources/WebsitePanel.EnterpriseServer/esVirtualizationServer2012.asmx.cs Normal file
View file

@ -0,0 +1,476 @@
// Copyright (c) 2015, Outercurve Foundation.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// - Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// - Neither the name of the Outercurve Foundation nor the names of its
// contributors may be used to endorse or promote products derived from this
// software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using System;
using System.Data;
using System.Web;
using System.Collections;
using System.Collections.Generic;
using System.Web.Services;
using System.Web.Services.Protocols;
using System.ComponentModel;
using WebsitePanel.Providers.Common;
using WebsitePanel.Providers.ResultObjects;
using Microsoft.Web.Services3;
using WebsitePanel.Providers;
using WebsitePanel.Providers.Common;
using WebsitePanel.Providers.Virtualization;
using WebsitePanel.Providers.ResultObjects;
using WebsitePanel.Providers.Virtualization;
namespace WebsitePanel.EnterpriseServer
{
/// <summary>
/// Summary description for esVirtualizationServer
/// </summary>
[WebService(Namespace = "http://smbsaas/websitepanel/enterpriseserver")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
[Policy("ServerPolicy")]
[ToolboxItem(false)]
public class esVirtualizationServer2012 : System.Web.Services.WebService
{
#region Virtual Machines
[WebMethod]
public VirtualMachineMetaItemsPaged GetVirtualMachines(int packageId,
string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows, bool recursive)
{
return VirtualizationServerController2012.GetVirtualMachines(packageId,
filterColumn, filterValue, sortColumn, startRow, maximumRows, recursive);
}
[WebMethod]
public VirtualMachine[] GetVirtualMachinesByServiceId(int serviceId)
{
return VirtualizationServerController2012.GetVirtualMachinesByServiceId(serviceId);
}
[WebMethod]
public VirtualMachine GetVirtualMachineItem(int itemId)
{
return VirtualizationServerController2012.GetVirtualMachineByItemId(itemId);
}
[WebMethod]
public string EvaluateVirtualMachineTemplate(int itemId, string template)
{
if (SecurityContext.CheckAccount(DemandAccount.IsActive | DemandAccount.IsAdmin | DemandAccount.NotDemo) != 0)
throw new Exception("This method could be called by serveradmin only.");
return VirtualizationServerController2012.EvaluateVirtualMachineTemplate(itemId, false, false, template);
}
#endregion
#region External Network
[WebMethod]
public NetworkAdapterDetails GetExternalNetworkDetails(int packageId)
{
return VirtualizationServerController2012.GetExternalNetworkDetails(packageId);
}
#endregion
#region Private Network
[WebMethod]
public PrivateIPAddressesPaged GetPackagePrivateIPAddressesPaged(int packageId,
string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
{
return VirtualizationServerController2012.GetPackagePrivateIPAddressesPaged(packageId,
filterColumn, filterValue, sortColumn, startRow, maximumRows);
}
[WebMethod]
public List<PrivateIPAddress> GetPackagePrivateIPAddresses(int packageId)
{
return VirtualizationServerController2012.GetPackagePrivateIPAddresses(packageId);
}
[WebMethod]
public NetworkAdapterDetails GetPrivateNetworkDetails(int packageId)
{
return VirtualizationServerController2012.GetPrivateNetworkDetails(packageId);
}
#endregion
#region User Permissions
[WebMethod]
public List<VirtualMachinePermission> GetSpaceUserPermissions(int packageId)
{
return VirtualizationServerController2012.GetSpaceUserPermissions(packageId);
}
[WebMethod]
public int UpdateSpaceUserPermissions(int packageId, VirtualMachinePermission[] permissions)
{
return VirtualizationServerController2012.UpdateSpaceUserPermissions(packageId, permissions);
}
#endregion
#region Audit Log
[WebMethod]
public List<LogRecord> GetSpaceAuditLog(int packageId, DateTime startPeriod, DateTime endPeriod,
int severity, string sortColumn, int startRow, int maximumRows)
{
return VirtualizationServerController2012.GetSpaceAuditLog(packageId, startPeriod, endPeriod,
severity, sortColumn, startRow, maximumRows);
}
[WebMethod]
public List<LogRecord> GetVirtualMachineAuditLog(int itemId, DateTime startPeriod, DateTime endPeriod,
int severity, string sortColumn, int startRow, int maximumRows)
{
return VirtualizationServerController2012.GetVirtualMachineAuditLog(itemId, startPeriod, endPeriod,
severity, sortColumn, startRow, maximumRows);
}
#endregion
#region VPS Create – Name & OS
[WebMethod]
public LibraryItem[] GetOperatingSystemTemplates(int packageId)
{
return VirtualizationServerController2012.GetOperatingSystemTemplates(packageId);
}
[WebMethod]
public LibraryItem[] GetOperatingSystemTemplatesByServiceId(int serviceId)
{
return VirtualizationServerController2012.GetOperatingSystemTemplatesByServiceId(serviceId);
}
#endregion
#region VPS Create - Configuration
[WebMethod]
public int GetMaximumCpuCoresNumber(int packageId)
{
return VirtualizationServerController2012.GetMaximumCpuCoresNumber(packageId);
}
[WebMethod]
public string GetDefaultExportPath(int itemId)
{
return VirtualizationServerController2012.GetDefaultExportPath(itemId);
}
#endregion
#region VPS Create
[WebMethod]
public IntResult CreateDefaultVirtualMachine(int packageId,
string hostname, string osTemplate, string password, string summaryLetterEmail)
{
return VirtualizationServerController2012.CreateDefaultVirtualMachine(packageId, hostname, osTemplate, password, summaryLetterEmail);
}
[WebMethod]
public IntResult CreateVirtualMachine(int packageId,
string hostname, string osTemplateFile, string password, string summaryLetterEmail,
int cpuCores, int ramMB, int hddGB, int snapshots, bool dvdInstalled, bool bootFromCD, bool numLock,
bool startShutdownAllowed, bool pauseResumeAllowed, bool rebootAllowed, bool resetAllowed, bool reinstallAllowed,
bool externalNetworkEnabled, int externalAddressesNumber, bool randomExternalAddresses, int[] externalAddresses,
bool privateNetworkEnabled, int privateAddressesNumber, bool randomPrivateAddresses, string[] privateAddresses, VirtualMachine otherSettings)
{
return VirtualizationServerController2012.CreateVirtualMachine(packageId,
hostname, osTemplateFile, password, summaryLetterEmail,
cpuCores, ramMB, hddGB, snapshots, dvdInstalled, bootFromCD, numLock,
startShutdownAllowed, pauseResumeAllowed, rebootAllowed, resetAllowed, reinstallAllowed,
externalNetworkEnabled, externalAddressesNumber, randomExternalAddresses, externalAddresses,
privateNetworkEnabled, privateAddressesNumber, randomPrivateAddresses, privateAddresses, otherSettings);
}
#endregion
#region VPS - Import
[WebMethod]
public IntResult ImportVirtualMachine(int packageId,
int serviceId, string vmId,
string osTemplateFile, string adminPassword,
bool startShutdownAllowed, bool pauseResumeAllowed, bool rebootAllowed, bool resetAllowed, bool reinstallAllowed,
string externalNicMacAddress, int[] externalAddresses,
string managementNicMacAddress, int managementAddress)
{
return VirtualizationServerController2012.ImportVirtualMachine(packageId,
serviceId, vmId,
osTemplateFile, adminPassword,
startShutdownAllowed, pauseResumeAllowed, rebootAllowed, resetAllowed, reinstallAllowed,
externalNicMacAddress, externalAddresses,
managementNicMacAddress, managementAddress);
}
#endregion
#region VPS – General
[WebMethod]
public byte[] GetVirtualMachineThumbnail(int itemId, ThumbnailSize size)
{
return VirtualizationServerController2012.GetVirtualMachineThumbnail(itemId, size);
}
[WebMethod]
public VirtualMachine GetVirtualMachineGeneralDetails(int itemId)
{
return VirtualizationServerController2012.GetVirtualMachineGeneralDetails(itemId);
}
[WebMethod]
public VirtualMachine GetVirtualMachineExtendedInfo(int serviceId, string vmId)
{
return VirtualizationServerController2012.GetVirtualMachineExtendedInfo(serviceId, vmId);
}
[WebMethod]
public int CancelVirtualMachineJob(string jobId)
{
return VirtualizationServerController2012.CancelVirtualMachineJob(jobId);
}
[WebMethod]
public ResultObject UpdateVirtualMachineHostName(int itemId, string hostname, bool updateNetBIOS)
{
return VirtualizationServerController2012.UpdateVirtualMachineHostName(itemId, hostname, updateNetBIOS);
}
[WebMethod]
public ResultObject ChangeVirtualMachineState(int itemId, VirtualMachineRequestedState state)
{
return VirtualizationServerController2012.ChangeVirtualMachineStateExternal(itemId, state);
}
[WebMethod]
public List<ConcreteJob> GetVirtualMachineJobs(int itemId)
{
return VirtualizationServerController2012.GetVirtualMachineJobs(itemId);
}
#endregion
#region VPS - Configuration
[WebMethod]
public ResultObject ChangeAdministratorPassword(int itemId, string password)
{
return VirtualizationServerController2012.ChangeAdministratorPassword(itemId, password);
}
#endregion
#region VPS – Edit Configuration
[WebMethod]
public ResultObject UpdateVirtualMachineConfiguration(int itemId, int cpuCores, int ramMB, int hddGB, int snapshots,
bool dvdInstalled, bool bootFromCD, bool numLock,
bool startShutdownAllowed, bool pauseResumeAllowed, bool rebootAllowed, bool resetAllowed, bool reinstallAllowed,
bool externalNetworkEnabled,
bool privateNetworkEnabled, VirtualMachine otherSettings)
{
return VirtualizationServerController2012.UpdateVirtualMachineConfiguration(
itemId, cpuCores, ramMB, hddGB, snapshots,
dvdInstalled, bootFromCD, numLock,
startShutdownAllowed, pauseResumeAllowed, rebootAllowed, resetAllowed, reinstallAllowed,
externalNetworkEnabled, privateNetworkEnabled,
otherSettings);
}
#endregion
#region DVD
[WebMethod]
public LibraryItem GetInsertedDvdDisk(int itemId)
{
return VirtualizationServerController2012.GetInsertedDvdDisk(itemId);
}
[WebMethod]
public LibraryItem[] GetLibraryDisks(int itemId)
{
return VirtualizationServerController2012.GetLibraryDisks(itemId);
}
[WebMethod]
public ResultObject InsertDvdDisk(int itemId, string isoPath)
{
return VirtualizationServerController2012.InsertDvdDisk(itemId, isoPath);
}
[WebMethod]
public ResultObject EjectDvdDisk(int itemId)
{
return VirtualizationServerController2012.EjectDvdDisk(itemId);
}
#endregion
#region Snaphosts
[WebMethod]
public VirtualMachineSnapshot[] GetVirtualMachineSnapshots(int itemId)
{
return VirtualizationServerController2012.GetVirtualMachineSnapshots(itemId);
}
[WebMethod]
public VirtualMachineSnapshot GetSnapshot(int itemId, string snaphostId)
{
return VirtualizationServerController2012.GetSnapshot(itemId, snaphostId);
}
[WebMethod]
public ResultObject CreateSnapshot(int itemId)
{
return VirtualizationServerController2012.CreateSnapshot(itemId);
}
[WebMethod]
public ResultObject ApplySnapshot(int itemId, string snapshotId)
{
return VirtualizationServerController2012.ApplySnapshot(itemId, snapshotId);
}
[WebMethod]
public ResultObject RenameSnapshot(int itemId, string snapshotId, string newName)
{
return VirtualizationServerController2012.RenameSnapshot(itemId, snapshotId, newName);
}
[WebMethod]
public ResultObject DeleteSnapshot(int itemId, string snapshotId)
{
return VirtualizationServerController2012.DeleteSnapshot(itemId, snapshotId);
}
[WebMethod]
public ResultObject DeleteSnapshotSubtree(int itemId, string snapshotId)
{
return VirtualizationServerController2012.DeleteSnapshotSubtree(itemId, snapshotId);
}
[WebMethod]
public byte[] GetSnapshotThumbnail(int itemId, string snapshotId, ThumbnailSize size)
{
return VirtualizationServerController2012.GetSnapshotThumbnail(itemId, snapshotId, size);
}
#endregion
#region VPS - External Network
[WebMethod]
public NetworkAdapterDetails GetExternalNetworkAdapterDetails(int itemId)
{
return VirtualizationServerController2012.GetExternalNetworkAdapterDetails(itemId);
}
[WebMethod]
public ResultObject AddVirtualMachineExternalIPAddresses(int itemId, bool selectRandom,
int addressesNumber, int[] addressId)
{
return VirtualizationServerController2012.AddVirtualMachineExternalIPAddresses(itemId, selectRandom,
addressesNumber, addressId, true);
}
[WebMethod]
public ResultObject SetVirtualMachinePrimaryExternalIPAddress(int itemId, int addressId)
{
return VirtualizationServerController2012.SetVirtualMachinePrimaryExternalIPAddress(itemId, addressId, true);
}
[WebMethod]
public ResultObject DeleteVirtualMachineExternalIPAddresses(int itemId, int[] addressId)
{
return VirtualizationServerController2012.DeleteVirtualMachineExternalIPAddresses(itemId, addressId, true);
}
#endregion
#region VPS – Private Network
[WebMethod]
public NetworkAdapterDetails GetPrivateNetworkAdapterDetails(int itemId)
{
return VirtualizationServerController2012.GetPrivateNetworkAdapterDetails(itemId);
}
[WebMethod]
public ResultObject AddVirtualMachinePrivateIPAddresses(int itemId, bool selectRandom,
int addressesNumber, string[] addresses)
{
return VirtualizationServerController2012.AddVirtualMachinePrivateIPAddresses(itemId, selectRandom,
addressesNumber, addresses, true);
}
[WebMethod]
public ResultObject SetVirtualMachinePrimaryPrivateIPAddress(int itemId, int addressId)
{
return VirtualizationServerController2012.SetVirtualMachinePrimaryPrivateIPAddress(itemId, addressId, true);
}
[WebMethod]
public ResultObject DeleteVirtualMachinePrivateIPAddresses(int itemId, int[] addressId)
{
return VirtualizationServerController2012.DeleteVirtualMachinePrivateIPAddresses(itemId, addressId, true);
}
#endregion
#region Virtual Machine Permissions
[WebMethod]
public List<VirtualMachinePermission> GetVirtualMachinePermissions(int itemId)
{
return VirtualizationServerController2012.GetVirtualMachinePermissions(itemId);
}
[WebMethod]
public int UpdateVirtualMachineUserPermissions(int itemId, VirtualMachinePermission[] permissions)
{
return VirtualizationServerController2012.UpdateVirtualMachineUserPermissions(itemId, permissions);
}
#endregion
#region Virtual Switches
[WebMethod]
public VirtualSwitch[] GetExternalSwitches(int serviceId, string computerName)
{
return VirtualizationServerController2012.GetExternalSwitches(serviceId, computerName);
}
#endregion
#region Tools
[WebMethod]
public ResultObject DeleteVirtualMachine(int itemId, bool saveFiles, bool exportVps, string exportPath)
{
return VirtualizationServerController2012.DeleteVirtualMachine(itemId, saveFiles, exportVps, exportPath);
}
[WebMethod]
public int ReinstallVirtualMachine(int itemId, string adminPassword, bool preserveVirtualDiskFiles,
bool saveVirtualDisk, bool exportVps, string exportPath)
{
return VirtualizationServerController2012.ReinstallVirtualMachine(itemId, adminPassword, preserveVirtualDiskFiles,
saveVirtualDisk, exportVps, exportPath);
}
#endregion
#region Help
[WebMethod]
public string GetVirtualMachineSummaryText(int itemId)
{
return VirtualizationServerController2012.GetVirtualMachineSummaryText(itemId, false, false);
}
[WebMethod]
public ResultObject SendVirtualMachineSummaryLetter(int itemId, string to, string bcc)
{
return VirtualizationServerController2012.SendVirtualMachineSummaryLetter(itemId, to, bcc, false);
}
#endregion
}
}

2
WebsitePanel/Sources/WebsitePanel.Providers.Base/Common/PersistentAttribute.cs
View file

@ -30,7 +30,7 @@ using System;
namespace WebsitePanel.Providers
{
[AttributeUsage(AttributeTargets.Property)]
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Class)]
public class PersistentAttribute : Attribute
{
public PersistentAttribute()

52
WebsitePanel/Sources/WebsitePanel.Providers.Base/Virtualization/DynamicMemory.cs Normal file
View file

@ -0,0 +1,52 @@
// Copyright (c) 2015, Outercurve Foundation.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// - Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// - Neither the name of the Outercurve Foundation nor the names of its
// contributors may be used to endorse or promote products derived from this
// software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using System;
namespace WebsitePanel.Providers.Virtualization
{
[Persistent]
public class DynamicMemory
{
[Persistent]
public bool Enabled { get; set; }
[Persistent]
public int Minimum { get; set; }
[Persistent]
public int Maximum { get; set; }
[Persistent]
public int Buffer { get; set; }
[Persistent]
public int Priority { get; set; } // Weight
}
}

4
WebsitePanel/Sources/WebsitePanel.Providers.Base/Virtualization/VirtualMachine.cs
View file

@ -71,6 +71,10 @@ namespace WebsitePanel.Providers.Virtualization
[Persistent]
public int RamSize { get; set; }
public int RamUsage { get; set; }
[Persistent]
public DynamicMemory DynamicMemory { get; set; }
[Persistent]
public int HddSize { get; set; }
public LogicalDisk[] HddLogicalDisks { get; set; }

2
WebsitePanel/Sources/WebsitePanel.Providers.Base/WebsitePanel.Providers.Base.csproj
View file

@ -321,7 +321,6 @@
<Compile Include="Virtualization\LibraryItem.cs" />
<Compile Include="Virtualization\LogicalDisk.cs" />
<Compile Include="Virtualization\DvdDriveInfo.cs" />
<Compile Include="Virtualization\MemoryInfo.cs" />
<Compile Include="Virtualization\MonitoredObjectAlert.cs" />
<Compile Include="Virtualization\MonitoredObjectEvent.cs" />
<Compile Include="Virtualization\MountedDiskInfo.cs" />
@ -339,6 +338,7 @@
<Compile Include="Virtualization\VirtualHardDiskFormat.cs" />
<Compile Include="Virtualization\VirtualHardDiskInfo.cs" />
<Compile Include="Virtualization\VirtualHardDiskType.cs" />
<Compile Include="Virtualization\DynamicMemory.cs" />
<Compile Include="Virtualization\VirtualMachine.cs">
<SubType>Code</SubType>
</Compile>

60
WebsitePanel/Sources/WebsitePanel.Providers.TerminalServices.Windows2012/Windows2012.cs
View file

@ -376,9 +376,12 @@ namespace WebsitePanel.Providers.RemoteDesktopServices
AddComputerToCollectionAdComputerGroup(organizationId, collection.Name, rdsServer);
}
CreatePolicy(runSpace, organizationId, string.Format("{0}-administrators", collection.Name), new DirectoryEntry(GetGroupPath(organizationId, collection.Name, GetLocalAdminsGroupName(collection.Name))), collection.Name);
CreatePolicy(runSpace, organizationId, string.Format("{0}-users", collection.Name), new DirectoryEntry(GetUsersGroupPath(organizationId, collection.Name)), collection.Name);
CreateHelpDeskPolicy(runSpace, new DirectoryEntry(GetHelpDeskGroupPath(RDSHelpDeskGroup)), organizationId, collection.Name);
string collectionComputersPath = GetComputerGroupPath(organizationId, collection.Name);
CreatePolicy(runSpace, organizationId, string.Format("{0}-administrators", collection.Name),
new DirectoryEntry(GetGroupPath(organizationId, collection.Name, GetLocalAdminsGroupName(collection.Name))), new DirectoryEntry(collectionComputersPath), collection.Name);
CreatePolicy(runSpace, organizationId, string.Format("{0}-users", collection.Name), new DirectoryEntry(GetUsersGroupPath(organizationId, collection.Name))
, new DirectoryEntry(collectionComputersPath), collection.Name);
CreateHelpDeskPolicy(runSpace, new DirectoryEntry(GetHelpDeskGroupPath(RDSHelpDeskGroup)), new DirectoryEntry(collectionComputersPath), organizationId, collection.Name);
}
finally
{
@ -1141,11 +1144,14 @@ namespace WebsitePanel.Providers.RemoteDesktopServices
try
{
runspace = OpenRunspace();
runspace = OpenRunspace();
string collectionComputersPath = GetComputerGroupPath(organizationId, collectionName);
CreatePolicy(runspace, organizationId, string.Format("{0}-administrators", collectionName), new DirectoryEntry(GetGroupPath(organizationId, collectionName, GetLocalAdminsGroupName(collectionName))), collectionName);
CreatePolicy(runspace, organizationId, string.Format("{0}-users", collectionName), new DirectoryEntry(GetUsersGroupPath(organizationId, collectionName)), collectionName);
CreateHelpDeskPolicy(runspace, new DirectoryEntry(GetHelpDeskGroupPath(RDSHelpDeskGroup)), organizationId, collectionName);
CreatePolicy(runspace, organizationId, string.Format("{0}-administrators", collectionName),
new DirectoryEntry(GetGroupPath(organizationId, collectionName, GetLocalAdminsGroupName(collectionName))), new DirectoryEntry(collectionComputersPath), collectionName);
CreatePolicy(runspace, organizationId, string.Format("{0}-users", collectionName),
new DirectoryEntry(GetUsersGroupPath(organizationId, collectionName)), new DirectoryEntry(collectionComputersPath), collectionName);
CreateHelpDeskPolicy(runspace, new DirectoryEntry(GetHelpDeskGroupPath(RDSHelpDeskGroup)), new DirectoryEntry(collectionComputersPath), organizationId, collectionName);
RemoveRegistryValue(runspace, ScreenSaverGpoKey, administratorsGpo);
RemoveRegistryValue(runspace, ScreenSaverGpoKey, usersGpo);
RemoveRegistryValue(runspace, RemoveRestartGpoKey, administratorsGpo);
@ -1194,6 +1200,25 @@ namespace WebsitePanel.Providers.RemoteDesktopServices
}
}
private void CheckPolicySecurityFiltering(Runspace runspace, string gpoName, DirectoryEntry collectionComputersEntry)
{
var scripts = new List<string>{
string.Format("Get-GPPermissions -Name {0} -TargetName {1} -TargetType group", gpoName, string.Format("'{0}'", ActiveDirectoryUtils.GetADObjectProperty(collectionComputersEntry, "sAMAccountName").ToString()))
};
object[] errors = null;
ExecuteRemoteShellCommand(runspace, PrimaryDomainController, scripts, out errors);
if (errors != null && errors.Any())
{
scripts = new List<string>{
string.Format("Set-GPPermissions -Name {0} -PermissionLevel gpoapply -TargetName {1} -TargetType group", gpoName, string.Format("'{0}'", ActiveDirectoryUtils.GetADObjectProperty(collectionComputersEntry, "sAMAccountName").ToString()))
};
}
ExecuteRemoteShellCommand(runspace, PrimaryDomainController, scripts, out errors);
}
private void SetPowershellPermissions(Runspace runspace, RdsServerSetting setting, string usersGpo, string administratorsGpo)
{
if (setting != null)
@ -1299,7 +1324,7 @@ namespace WebsitePanel.Providers.RemoteDesktopServices
Collection<PSObject> result = ExecuteRemoteShellCommand(runspace, PrimaryDomainController, cmd);
}
private void CreateHelpDeskPolicy(Runspace runspace, DirectoryEntry entry, string organizationId, string collectionName)
private void CreateHelpDeskPolicy(Runspace runspace, DirectoryEntry entry, DirectoryEntry collectionComputersEntry, string organizationId, string collectionName)
{
string gpoName = string.Format("{0}-HelpDesk", collectionName);
string gpoId = GetPolicyId(runspace, gpoName);
@ -1307,19 +1332,27 @@ namespace WebsitePanel.Providers.RemoteDesktopServices
if (string.IsNullOrEmpty(gpoId))
{
gpoId = CreateAndLinkPolicy(runspace, gpoName, organizationId, collectionName);
SetPolicyPermissions(runspace, gpoName, entry);
SetPolicyPermissions(runspace, gpoName, entry, collectionComputersEntry);
SetRegistryValue(runspace, RDSSessionGpoKey, gpoName, "2", RDSSessionGpoValueName, "DWord");
}
else
{
CheckPolicySecurityFiltering(runspace, gpoName, collectionComputersEntry);
}
}
private string CreatePolicy(Runspace runspace, string organizationId, string gpoName, DirectoryEntry entry, string collectionName)
private string CreatePolicy(Runspace runspace, string organizationId, string gpoName, DirectoryEntry entry, DirectoryEntry collectionComputersEntry, string collectionName)
{
string gpoId = GetPolicyId(runspace, gpoName);
if (string.IsNullOrEmpty(gpoId))
{
gpoId = CreateAndLinkPolicy(runspace, gpoName, organizationId, collectionName);
SetPolicyPermissions(runspace, gpoName, entry);
SetPolicyPermissions(runspace, gpoName, entry, collectionComputersEntry);
}
else
{
CheckPolicySecurityFiltering(runspace, gpoName, collectionComputersEntry);
}
return gpoId;
@ -1339,12 +1372,13 @@ namespace WebsitePanel.Providers.RemoteDesktopServices
Collection<PSObject> result = ExecuteRemoteShellCommand(runspace, PrimaryDomainController, cmd);
}
private void SetPolicyPermissions(Runspace runspace, string gpoName, DirectoryEntry entry)
private void SetPolicyPermissions(Runspace runspace, string gpoName, DirectoryEntry entry, DirectoryEntry collectionComputersEntry)
{
var scripts = new List<string>
{
string.Format("Set-GPPermissions -Name {0} -Replace -PermissionLevel None -TargetName 'Authenticated Users' -TargetType group", gpoName),
string.Format("Set-GPPermissions -Name {0} -PermissionLevel gpoapply -TargetName {1} -TargetType group", gpoName, string.Format("'{0}'", ActiveDirectoryUtils.GetADObjectProperty(entry, "sAMAccountName").ToString()))
string.Format("Set-GPPermissions -Name {0} -PermissionLevel gpoapply -TargetName {1} -TargetType group", gpoName, string.Format("'{0}'", ActiveDirectoryUtils.GetADObjectProperty(entry, "sAMAccountName").ToString())),
string.Format("Set-GPPermissions -Name {0} -PermissionLevel gpoapply -TargetName {1} -TargetType group", gpoName, string.Format("'{0}'", ActiveDirectoryUtils.GetADObjectProperty(collectionComputersEntry, "sAMAccountName").ToString()))
};
object[] errors = null;

4
WebsitePanel/Sources/WebsitePanel.Providers.Virtualization.HyperV-2012R2/Extensions/PSObjectExtension.cs
View file

@ -36,6 +36,10 @@ namespace WebsitePanel.Providers.Virtualization
{
return obj.Members[name].Value == null ? "" : obj.Members[name].Value.ToString();
}
public static bool GetBool(this PSObject obj, string name)
{
return Convert.ToBoolean(obj.Members[name].Value);
}
#endregion

58
WebsitePanel/Sources/WebsitePanel.Providers.Virtualization.HyperV-2012R2/Helpers/MemoryHelper.cs Normal file
View file

@ -0,0 +1,58 @@
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Management.Automation;
using System.Management.Automation.Runspaces;
using System.Text;
using System.Threading.Tasks;
namespace WebsitePanel.Providers.Virtualization
{
public static class MemoryHelper
{
public static DynamicMemory GetDynamicMemory(PowerShellManager powerShell, string vmName)
{
DynamicMemory info = null;
Command cmd = new Command("Get-VMMemory");
cmd.Parameters.Add("VMName", vmName);
Collection<PSObject> result = powerShell.Execute(cmd);
if (result != null && result.Count > 0)
{
info = new DynamicMemory();
info.Enabled = result[0].GetBool("DynamicMemoryEnabled");
info.Minimum = Convert.ToInt32(result[0].GetLong("Minimum") / Constants.Size1M);
info.Maximum = Convert.ToInt32(result[0].GetLong("Maximum") / Constants.Size1M);
info.Buffer = Convert.ToInt32(result[0].GetInt("Buffer"));
info.Priority = Convert.ToInt32(result[0].GetInt("Priority"));
}
return info;
}
public static void Update(PowerShellManager powerShell, VirtualMachine vm, int ramMb, DynamicMemory dynamicMemory)
{
Command cmd = new Command("Set-VMMemory");
cmd.Parameters.Add("VMName", vm.Name);
cmd.Parameters.Add("StartupBytes", ramMb * Constants.Size1M);
if (dynamicMemory != null && dynamicMemory.Enabled)
{
cmd.Parameters.Add("DynamicMemoryEnabled", true);
cmd.Parameters.Add("MinimumBytes", dynamicMemory.Minimum * Constants.Size1M);
cmd.Parameters.Add("MaximumBytes", dynamicMemory.Maximum * Constants.Size1M);
cmd.Parameters.Add("Buffer", dynamicMemory.Buffer);
cmd.Parameters.Add("Priority", dynamicMemory.Priority);
}
else
{
cmd.Parameters.Add("DynamicMemoryEnabled", false);
}
powerShell.Execute(cmd, true);
}
}
}

32
WebsitePanel/Sources/WebsitePanel.Providers.Virtualization.HyperV-2012R2/Helpers/VirtualMachineHelper.cs
View file

@ -34,7 +34,6 @@ namespace WebsitePanel.Providers.Virtualization
public static int GetVMProcessors(PowerShellManager powerShell, string name)
{
int procs = 0;
Command cmd = new Command("Get-VMProcessor");
@ -50,27 +49,6 @@ namespace WebsitePanel.Providers.Virtualization
return procs;
}
public static MemoryInfo GetVMMemory(PowerShellManager powerShell, string name)
{
MemoryInfo info = new MemoryInfo();
Command cmd = new Command("Get-VMMemory");
cmd.Parameters.Add("VMName", name);
Collection<PSObject> result = powerShell.Execute(cmd, true);
if (result != null && result.Count > 0)
{
info.DynamicMemoryEnabled = Convert.ToBoolean(result[0].GetProperty("DynamicMemoryEnabled"));
info.Startup = Convert.ToInt32(Convert.ToInt64(result[0].GetProperty("Startup")) / Constants.Size1M);
info.Minimum = Convert.ToInt32(Convert.ToInt64(result[0].GetProperty("Minimum")) / Constants.Size1M);
info.Maximum = Convert.ToInt32(Convert.ToInt64(result[0].GetProperty("Maximum")) / Constants.Size1M);
info.Buffer = Convert.ToInt32(result[0].GetProperty("Buffer"));
info.Priority = Convert.ToInt32(result[0].GetProperty("Priority"));
}
return info;
}
public static void UpdateProcessors(PowerShellManager powerShell, VirtualMachine vm, int cpuCores, int cpuLimitSettings, int cpuReserveSettings, int cpuWeightSettings)
{
Command cmd = new Command("Set-VMProcessor");
@ -83,15 +61,5 @@ namespace WebsitePanel.Providers.Virtualization
powerShell.Execute(cmd, true);
}
public static void UpdateMemory(PowerShellManager powerShell, VirtualMachine vm, long ramMB)
{
Command cmd = new Command("Set-VMMemory");
cmd.Parameters.Add("VMName", vm.Name);
cmd.Parameters.Add("StartupBytes", ramMB * Constants.Size1M);
powerShell.Execute(cmd, true);
}
}
}

83
WebsitePanel/Sources/WebsitePanel.Providers.Virtualization.HyperV-2012R2/HyperV2012R2.cs
View file

@ -143,18 +143,17 @@ namespace WebsitePanel.Providers.Virtualization
try
{
Command cmd = new Command("Get-VM");
cmd.Parameters.Add("Id", vmId);
Collection<PSObject> result = PowerShell.Execute(cmd, true);
if (result != null && result.Count > 0)
{
vm.Name = result[0].GetProperty("Name").ToString();
vm.Name = result[0].GetString("Name");
vm.State = result[0].GetEnum<VirtualMachineState>("State");
vm.CpuUsage = ConvertNullableToInt32(result[0].GetProperty("CpuUsage"));
// This does not truly give the RAM usage, only the memory assigned to the VPS
// Lets handle detection of total memory and usage else where
//vm.RamUsage = Convert.ToInt32(ConvertNullableToInt64(result[0].GetProperty("MemoryAssigned")) / Constants.Size1M);
// Lets handle detection of total memory and usage else where. SetUsagesFromKVP method have been made for it.
vm.RamUsage = Convert.ToInt32(ConvertNullableToInt64(result[0].GetProperty("MemoryAssigned")) / Constants.Size1M);
vm.RamSize = Convert.ToInt32(ConvertNullableToInt64(result[0].GetProperty("MemoryStartup")) / Constants.Size1M);
vm.Uptime = Convert.ToInt64(result[0].GetProperty<TimeSpan>("UpTime").TotalMilliseconds);
vm.Status = result[0].GetProperty("Status").ToString();
@ -162,18 +161,13 @@ namespace WebsitePanel.Providers.Virtualization
vm.Generation = result[0].GetInt("Generation");
vm.ProcessorCount = result[0].GetInt("ProcessorCount");
vm.ParentSnapshotId = result[0].GetString("ParentSnapshotId");
vm.Heartbeat = VirtualMachineHelper.GetVMHeartBeatStatus(PowerShell, vm.Name);
vm.CreatedDate = DateTime.Now;
if (extendedInfo)
{
vm.CpuCores = VirtualMachineHelper.GetVMProcessors(PowerShell, vm.Name);
MemoryInfo memoryInfo = VirtualMachineHelper.GetVMMemory(PowerShell, vm.Name);
vm.RamSize = memoryInfo.Startup;
// BIOS
BiosInfo biosInfo = BiosHelper.Get(PowerShell, vm.Name, vm.Generation);
vm.NumLockEnabled = biosInfo.NumLockEnabled;
@ -195,38 +189,11 @@ namespace WebsitePanel.Providers.Virtualization
// network adapters
vm.Adapters = NetworkAdapterHelper.Get(PowerShell, vm.Name);
}
else
{
// Use the WebsitePanel VMConfig Windows service to get the RAM usage as well as the HDD usage / sizes
List<KvpExchangeDataItem> vmKvps = GetKVPItems(vmId);
foreach (KvpExchangeDataItem vmKvp in vmKvps)
{
// RAM
if (vmKvp.Name == Constants.KVP_RAM_SUMMARY_KEY)
{
string[] ram = vmKvp.Data.Split(':');
int freeRam = Int32.Parse(ram[0]);
int availRam = Int32.Parse(ram[1]);
vm.RamUsage = availRam - freeRam;
}
vm.DynamicMemory = MemoryHelper.GetDynamicMemory(PowerShell, vm.Name);
// HDD
if (vmKvp.Name == Constants.KVP_HDD_SUMMARY_KEY)
{
string[] disksArray = vmKvp.Data.Split(';');
vm.HddLogicalDisks = new LogicalDisk[disksArray.Length];
for (int i = 0; i < disksArray.Length; i++)
{
string[] disk = disksArray[i].Split(':');
vm.HddLogicalDisks[i] = new LogicalDisk();
vm.HddLogicalDisks[i].DriveLetter = disk[0];
vm.HddLogicalDisks[i].FreeSpace = Int32.Parse(disk[1]);
vm.HddLogicalDisks[i].Size = Int32.Parse(disk[2]);
}
}
}
}
// If it is possible get usage ram and usage hdd data from KVP
SetUsagesFromKVP(ref vm);
}
}
catch (Exception ex)
@ -400,7 +367,7 @@ namespace WebsitePanel.Providers.Virtualization
DvdDriveHelper.Update(PowerShell, realVm, vm.DvdDriveInstalled); // Dvd should be before bios because bios sets boot order
BiosHelper.Update(PowerShell, realVm, vm.BootFromCD, vm.NumLockEnabled);
VirtualMachineHelper.UpdateProcessors(PowerShell, realVm, vm.CpuCores, CpuLimitSettings, CpuReserveSettings, CpuWeightSettings);
VirtualMachineHelper.UpdateMemory(PowerShell, realVm, vm.RamSize);
MemoryHelper.Update(PowerShell, realVm, vm.RamSize, vm.DynamicMemory);
NetworkAdapterHelper.Update(PowerShell, vm);
}
catch (Exception ex)
@ -1835,6 +1802,40 @@ namespace WebsitePanel.Providers.Virtualization
return jobCompleted;
}
private void SetUsagesFromKVP(ref VirtualMachine vm)
{
// Use the WebsitePanel VMConfig Windows service to get the RAM usage as well as the HDD usage / sizes
List<KvpExchangeDataItem> vmKvps = GetKVPItems(vm.VirtualMachineId);
foreach (KvpExchangeDataItem vmKvp in vmKvps)
{
// RAM
if (vmKvp.Name == Constants.KVP_RAM_SUMMARY_KEY)
{
string[] ram = vmKvp.Data.Split(':');
int freeRam = Int32.Parse(ram[0]);
int availRam = Int32.Parse(ram[1]);
vm.RamUsage = availRam - freeRam;
}
// HDD
if (vmKvp.Name == Constants.KVP_HDD_SUMMARY_KEY)
{
string[] disksArray = vmKvp.Data.Split(';');
vm.HddLogicalDisks = new LogicalDisk[disksArray.Length];
for (int i = 0; i < disksArray.Length; i++)
{
string[] disk = disksArray[i].Split(':');
vm.HddLogicalDisks[i] = new LogicalDisk
{
DriveLetter = disk[0],
FreeSpace = Int32.Parse(disk[1]),
Size = Int32.Parse(disk[2])
};
}
}
}
}
#endregion
#region Remote File Methods

3
WebsitePanel/Sources/WebsitePanel.Providers.Virtualization.HyperV-2012R2/PowerShellManager.cs
View file

@ -4,8 +4,6 @@ using System.Collections.ObjectModel;
using System.Linq;
using System.Management.Automation;
using System.Management.Automation.Runspaces;
using System.Text;
using System.Threading.Tasks;
using WebsitePanel.Providers.HostedSolution;
namespace WebsitePanel.Providers.Virtualization
@ -65,7 +63,6 @@ namespace WebsitePanel.Providers.Virtualization
public Collection<PSObject> Execute(Command cmd, bool addComputerNameParameter)
{
object[] errors;
return Execute(cmd, addComputerNameParameter, false);
}

1
WebsitePanel/Sources/WebsitePanel.Providers.Virtualization.HyperV-2012R2/WebsitePanel.Providers.Virtualization.HyperV2012R2.csproj
View file

@ -57,6 +57,7 @@
<Compile Include="Extensions\PSObjectExtension.cs" />
<Compile Include="Extensions\StringExtensions.cs" />
<Compile Include="Helpers\BiosHelper.cs" />
<Compile Include="Helpers\MemoryHelper.cs" />
<Compile Include="Helpers\VdsHelper.cs" />
<Compile Include="Helpers\HardDriveHelper.cs" />
<Compile Include="Helpers\NetworkAdapterHelper.cs" />

19
WebsitePanel/Sources/WebsitePanel.Server.sln
View file

@ -1,6 +1,6 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.31101.0
VisualStudioVersion = 12.0.30723.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Caching Application Block", "Caching Application Block", "{C8E6F2E4-A5B8-486A-A56E-92D864524682}"
ProjectSection(SolutionItems) = preProject
@ -152,13 +152,6 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebsitePanel.Providers.Mail
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebsitePanel.Providers.Virtualization.HyperV2012R2", "WebsitePanel.Providers.Virtualization.HyperV-2012R2\WebsitePanel.Providers.Virtualization.HyperV2012R2.csproj", "{EE40516B-93DF-4CAB-80C4-64DCE0B751CC}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebsitePanel.Providers.HostedSolution.SharePoint2013Ent", "WebsitePanel.Providers.HostedSolution.SharePoint2013Ent\WebsitePanel.Providers.HostedSolution.SharePoint2013Ent.csproj", "{0CF0C19E-7BFE-4A61-AF00-7B7CE7264252}"
ProjectSection(ProjectDependencies) = postProject
{684C932A-6C75-46AC-A327-F3689D89EB42} = {684C932A-6C75-46AC-A327-F3689D89EB42}
{A06DE5E4-4331-47E1-8F46-7B846146B559} = {A06DE5E4-4331-47E1-8F46-7B846146B559}
{E91E52F3-9555-4D00-B577-2B1DBDD87CA7} = {E91E52F3-9555-4D00-B577-2B1DBDD87CA7}
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@ -769,16 +762,6 @@ Global
{EE40516B-93DF-4CAB-80C4-64DCE0B751CC}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{EE40516B-93DF-4CAB-80C4-64DCE0B751CC}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{EE40516B-93DF-4CAB-80C4-64DCE0B751CC}.Release|x86.ActiveCfg = Release|Any CPU
{0CF0C19E-7BFE-4A61-AF00-7B7CE7264252}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{0CF0C19E-7BFE-4A61-AF00-7B7CE7264252}.Debug|Any CPU.Build.0 = Debug|Any CPU
{0CF0C19E-7BFE-4A61-AF00-7B7CE7264252}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{0CF0C19E-7BFE-4A61-AF00-7B7CE7264252}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{0CF0C19E-7BFE-4A61-AF00-7B7CE7264252}.Debug|x86.ActiveCfg = Debug|Any CPU
{0CF0C19E-7BFE-4A61-AF00-7B7CE7264252}.Release|Any CPU.ActiveCfg = Release|Any CPU
{0CF0C19E-7BFE-4A61-AF00-7B7CE7264252}.Release|Any CPU.Build.0 = Release|Any CPU
{0CF0C19E-7BFE-4A61-AF00-7B7CE7264252}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{0CF0C19E-7BFE-4A61-AF00-7B7CE7264252}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{0CF0C19E-7BFE-4A61-AF00-7B7CE7264252}.Release|x86.ActiveCfg = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

10
WebsitePanel/Sources/WebsitePanel.WebPortal/App_Containers/Default/VPS2012.ascx Normal file
View file

@ -0,0 +1,10 @@
<%@ Control Language="C#" AutoEventWireup="false" %>
<div class="VpsFooter">
<div class="VpsHeader">
<div class="VpsBottom">
<div class="Vps2012Body">
<asp:PlaceHolder ID="ContentPane" runat="server"></asp:PlaceHolder>
</div>
</div>
</div>
</div>

2
WebsitePanel/Sources/WebsitePanel.WebPortal/App_Data/ModulesData.config
View file

@ -69,6 +69,7 @@
</MenuItems>
</MenuItem>
<MenuItem pageID="SpaceVPS" resourceGroup="VPS"/>
<MenuItem pageID="SpaceVPS2012" resourceGroup="VPS2012"/>
<MenuItem pageID="SpaceVPSForPC" resourceGroup="VPSForPC"/>
<MenuItem pageID="SpaceExchangeServer" resourceGroup="Hosted Organizations"/>
<MenuItem pageID="SpaceSharedSSL" resourceGroup="OS" quota="Web.SharedSSL"/>
@ -123,6 +124,7 @@
</Group>
<Group pageID="SpaceHome" titleresourcekey="VPS" disabled="True">
<Icon pageID="SpaceVPS" resourceGroup="VPS" imageUrl="icons/vps_48.png" />
<Icon pageID="SpaceVPS2012" resourceGroup="VPS2012" imageUrl="icons/vps_48.png" />
<Icon pageID="SpaceVPSForPC" resourceGroup="VPSForPC" imageUrl="icons/vpsforpc_48.png" />
</Group>
<!--

31
WebsitePanel/Sources/WebsitePanel.WebPortal/App_Data/WebsitePanel_Modules.config
View file

@ -640,6 +640,37 @@
</Controls>
</ModuleDefinition>
<ModuleDefinition id="VPS2012">
<Controls>
<Control key="" src="WebsitePanel/VPS2012/VdcHome.ascx" title="VdcHome" type="View" />
<Control key="vdc_create_server" src="WebsitePanel/VPS2012/VdcCreateServer.ascx" title="VdcCreateServer" type="View" />
<Control key="vdc_import_server" src="WebsitePanel/VPS2012/VdcImportServer.ascx" title="VdcImportServer" type="View" />
<Control key="vdc_external_network" src="WebsitePanel/VPS2012/VdcExternalNetwork.ascx" title="VdcExternalNetwork" type="View" />
<Control key="vdc_management_network" src="WebsitePanel/VPS2012/VdcManagementNetwork.ascx" title="VdcManagementNetwork" type="View" />
<Control key="vdc_allocate_external_ip" src="WebsitePanel/VPS2012/VdcAddExternalAddress.ascx" title="VdcAddExternalAddress" type="View" />
<Control key="vdc_private_network" src="WebsitePanel/VPS2012/VdcPrivateNetwork.ascx" title="VdcPrivateNetwork" type="View" />
<Control key="vdc_permissions" src="WebsitePanel/VPS2012/VdcPermissions.ascx" title="VdcPermissions" type="View" />
<Control key="vdc_audit_log" src="WebsitePanel/VPS2012/VdcAuditLog.ascx" title="VdcAuditLog" type="View" />
<Control key="vps_general" src="WebsitePanel/VPS2012/VpsDetailsGeneral.ascx" title="VpsDetailsGeneral" type="View" />
<Control key="vps_config" src="WebsitePanel/VPS2012/VpsDetailsConfiguration.ascx" title="VpsDetailsConfiguration" type="View" />
<Control key="vps_edit_config" src="WebsitePanel/VPS2012/VpsDetailsEditConfiguration.ascx" title="VpsDetailsEditConfiguration" type="View" />
<Control key="vps_dvd" src="WebsitePanel/VPS2012/VpsDetailsDvd.ascx" title="VpsDetailsDvd" type="View" />
<Control key="vps_insert_dvd" src="WebsitePanel/VPS2012/VpsDetailsInsertDvd.ascx" title="VpsDetailsInsertDvd" type="View" />
<Control key="vps_snapshots" src="WebsitePanel/VPS2012/VpsDetailsSnapshots.ascx" title="VpsDetailsSnapshots" type="View" />
<Control key="vps_network" src="WebsitePanel/VPS2012/VpsDetailsNetwork.ascx" title="VpsDetailsNetwork" type="View" />
<Control key="vps_add_external_ip" src="WebsitePanel/VPS2012/VpsDetailsAddExternalAddress.ascx" title="VpsDetailsAddExternalAddress" type="View" />
<Control key="vps_add_private_ip" src="WebsitePanel/VPS2012/VpsDetailsAddPrivateAddress.ascx" title="VpsDetailsAddPrivateAddress" type="View" />
<Control key="vps_permissions" src="WebsitePanel/VPS2012/VpsDetailsPermissions.ascx" title="VpsDetailsNetworking" type="View" />
<Control key="vps_tools" src="WebsitePanel/VPS2012/VpsDetailsTools.ascx" title="VpsDetailsTools" type="View" />
<Control key="vps_audit_log" src="WebsitePanel/VPS2012/VpsDetailsAuditLog.ascx" title="VpsDetailsAuditLog" type="View" />
<Control key="vps_help" src="WebsitePanel/VPS2012/VpsDetailsHelp.ascx" title="VpsDetailsHelp" type="View" />
<Control key="vps_tools_delete" src="WebsitePanel/VPS2012/VpsToolsDeleteServer.ascx" title="VpsToolsDeleteServer" type="View" />
<Control key="vps_tools_move" src="WebsitePanel/VPS2012/VpsMoveServer.ascx" title="VpsMoveServer" type="View" />
<Control key="vps_tools_reinstall" src="WebsitePanel/VPS2012/VpsToolsReinstallServer.ascx" title="VpsToolsReinstallServer" type="View" />
</Controls>
</ModuleDefinition>
<ModuleDefinition id="VPSForPC">
<Controls>
<Control key="" src="WebsitePanel/VPSForPC/VdcHome.ascx" title="VdcHome" type="View" />

14
WebsitePanel/Sources/WebsitePanel.WebPortal/App_Data/WebsitePanel_Pages.config
View file

@ -652,6 +652,20 @@
</Content>
</Page>
<Page name="SpaceVPS2012" roles="Administrator,Reseller,PlatformCSR,ResellerCSR,PlatformHelpdesk,ResellerHelpdesk,User" hidden="True" skin="VPS.ascx" adminskin="VPS.ascx">
<Content id="LeftPane">
<Module moduleDefinitionID="UserAccountMenu" title="UserMenu" container="Clear.ascx">
<ModuleData ref="UserMenu"/>
</Module>
<Module moduleDefinitionID="SpaceMenu" title="SpaceMenu" container="Clear.ascx">
<ModuleData ref="SpaceMenu"/>
</Module>
</Content>
<Content id="ContentPane">
<Module moduleDefinitionID="VPS2012" title="VirtualPrivateServers2012" icon="" container="VPS2012.ascx" admincontainer="VPS2012.ascx" readOnlyRoles="PlatformCSR,ResellerCSR"/>
</Content>
</Page>
<Page name="SpaceVPSForPC" roles="Administrator,Reseller,PlatformCSR,ResellerCSR,PlatformHelpdesk,ResellerHelpdesk,User" hidden="True" skin="VPS.ascx" adminskin="VPS.ascx">
<Content id="LeftPane">
<Module moduleDefinitionID="UserAccountMenu" title="UserMenu" container="Clear.ascx">

6
WebsitePanel/Sources/WebsitePanel.WebPortal/App_GlobalResources/WebsitePanel_Pages.ascx.resx
View file

@ -444,6 +444,12 @@
<data name="PageTitle.SpaceVPS" xml:space="preserve">
<value>{user} - {space} - Virtual Private Servers</value>
</data>
<data name="PageName.SpaceVPS2012" xml:space="preserve">
<value>Virtual Private Servers 2012</value>
</data>
<data name="PageTitle.SpaceVPS2012" xml:space="preserve">
<value>{user} - {space} - Virtual Private Servers 2012</value>
</data>
<data name="PageName.SpaceWebIPAddresses" xml:space="preserve">
<value>IP Addresses</value>
</data>

71
WebsitePanel/Sources/WebsitePanel.WebPortal/App_GlobalResources/WebsitePanel_SharedResources.ascx.resx
View file

@ -4265,6 +4265,9 @@
<data name="VPS.VPS_QUOTA_WRONG_RAM" xml:space="preserve">
<value>RAM size must be a positive number and greater than zero</value>
</data>
<data name="VPS.VPS_QUOTA_NOT_IN_DYNAMIC_RAM" xml:space="preserve">
<value>RAM size must be between the minimum and maximum of the dynamic memory</value>
</data>
<data name="VPS.VPS_QUOTA_WRONG_SNAPSHOTS" xml:space="preserve">
<value>Snapshots must be a positive number and greater than zero</value>
</data>
@ -5126,6 +5129,74 @@
<data name="Quota.VPSForPC.StartShutdownAllowed" xml:space="preserve">
<value>Allow user to Start, Turn off VPS</value>
</data>
<data name="ResourceGroup.VPS2012" xml:space="preserve">
<value>Virtual Private Servers 2012</value>
</data>
<data name="AuditLogSource.VPS2012" xml:space="preserve">
<value>Virtual Private Servers 2012</value>
</data>
<data name="Quota.VPS2012.Bandwidth" xml:space="preserve">
<value>Monthly bandwidth, GB</value>
</data>
<data name="Quota.VPS2012.BootCdAllowed" xml:space="preserve">
<value>Boot from CD allowed</value>
</data>
<data name="Quota.VPS2012.BootCdEnabled" xml:space="preserve">
<value>Boot from CD</value>
</data>
<data name="Quota.VPS2012.CpuNumber" xml:space="preserve">
<value>Number of CPU cores</value>
</data>
<data name="Quota.VPS2012.DvdEnabled" xml:space="preserve">
<value>DVD drive</value>
</data>
<data name="Quota.VPS2012.ExternalIPAddressesNumber" xml:space="preserve">
<value>Number of External IP addresses</value>
</data>
<data name="Quota.VPS2012.ExternalNetworkEnabled" xml:space="preserve">
<value>External Network</value>
</data>
<data name="Quota.VPS2012.Hdd" xml:space="preserve">
<value>Hard Drive size, GB</value>
</data>
<data name="Quota.VPS2012.ManagingAllowed" xml:space="preserve">
<value>Allow user to create, delete VPS</value>
</data>
<data name="Quota.VPS2012.NumLockEnabled" xml:space="preserve">
<value>"Num Lock" by default</value>
</data>
<data name="Quota.VPS2012.PauseResumeAllowed" xml:space="preserve">
<value>Allow user to Pause, Resume VPS</value>
</data>
<data name="Quota.VPS2012.PrivateIPAddressesNumber" xml:space="preserve">
<value>Number of Private IP addresses per VPS</value>
</data>
<data name="Quota.VPS2012.PrivateNetworkEnabled" xml:space="preserve">
<value>Private Network</value>
</data>
<data name="Quota.VPS2012.Ram" xml:space="preserve">
<value>RAM size, MB</value>
</data>
<data name="Quota.VPS2012.RebootAllowed" xml:space="preserve">
<value>Allow user to Reboot VPS</value>
</data>
<data name="Quota.VPS2012.ReinstallAllowed" xml:space="preserve">
<value>Allow user to Re-install VPS</value>
</data>
<data name="Quota.VPS2012.ResetAlowed" xml:space="preserve">
<value>Allow user to Reset VPS</value>
</data>
<data name="Quota.VPS2012.ServersNumber" xml:space="preserve">
<value>Number of VPS</value>
</data>
<data name="Quota.VPS2012.SnapshotsNumber" xml:space="preserve">
<value>Number of Snaphots</value>
</data>
<data name="Quota.VPS2012.StartShutdownAllowed" xml:space="preserve">
<value>Allow user to Start, Turn off VPS</value>
</data>
<data name="Error.CreateCheckPointError" xml:space="preserve">
<value>Error creating CheckPoint</value>
</data>

6
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/App_LocalResources/SpaceQuotas.ascx.resx
View file

@ -180,7 +180,7 @@
<data name="lblOCSUsers.Text" xml:space="preserve">
<value>OCS Users:</value>
</data>
<data name="lblSharepointSites" xml:space="preserve">
<data name="lblSharepointSites.Text" xml:space="preserve">
<value>SharePoint Foundation Sites:</value>
</data>
<data name="lblUserAccounts.Text" xml:space="preserve">
@ -210,7 +210,7 @@
<data name="lblDeletedUsers.Text" xml:space="preserve">
<value>Deleted Users:</value>
</data>
<data name="lblSharepointEnterpriseSites" xml:space="preserve">
<value>SharePoint Enterprise Sites:</value>
<data name="lblSharepointEnterpriseSites.Text" xml:space="preserve">
<value>SharePoint Server Sites:</value>
</data>
</root>

3
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/App_LocalResources/SpaceSettings.ascx.resx
View file

@ -141,6 +141,9 @@
<data name="lnkVps.Text" xml:space="preserve">
<value>Virtual Private Servers</value>
</data>
<data name="lnkVps2012.Text" xml:space="preserve">
<value>Virtual Private Servers 2012</value>
</data>
<data name="lnkVpsForPC.Text" xml:space="preserve">
<value>Virtual Private Servers for Private Cloud</value>
</data>

5
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/Code/Framework/ES.cs
View file

@ -68,6 +68,11 @@ namespace WebsitePanel.Portal
get { return GetCachedProxy<esVirtualizationServer>(); }
}
public esVirtualizationServer2012 VPS2012
{
get { return GetCachedProxy<esVirtualizationServer2012>(); }
}
public esVirtualizationServerForPrivateCloud VPSPC
{
get { return GetCachedProxy<esVirtualizationServerForPrivateCloud>(); }

34
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/Code/Helpers/VirtualMachineSettingExtensions.cs Normal file
View file

@ -0,0 +1,34 @@
using System.Collections.Generic;
using System.Web.UI;
using WebsitePanel.Providers.Virtualization;
namespace WebsitePanel.Portal.Code.Helpers
{
public static class VirtualMachineSettingExtensions
{
public static void BindSettingsControls(this Control page, VirtualMachine vm)
{
page.GetSettingsControls().ForEach(s => s.BindItem(vm));
}
public static void SaveSettingsControls(this Control page, ref VirtualMachine vm)
{
foreach (var s in page.GetSettingsControls()) s.SaveItem(ref vm);
}
public static List<IVirtualMachineSettingsControl> GetSettingsControls(this Control parent)
{
var result = new List<IVirtualMachineSettingsControl>();
foreach (Control control in parent.Controls)
{
if (control is IVirtualMachineSettingsControl)
result.Add((IVirtualMachineSettingsControl)control);
if (control.HasControls())
result.AddRange(control.GetSettingsControls());
}
return result;
}
}
}

129
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/Code/Helpers/VirtualMachines2012Helper.cs Normal file
View file

@ -0,0 +1,129 @@
// Copyright (c) 2015, Outercurve Foundation.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// - Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// - Neither the name of the Outercurve Foundation nor the names of its
// contributors may be used to endorse or promote products derived from this
// software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using WebsitePanel.EnterpriseServer;
using WebsitePanel.Providers.Virtualization;
using System.Web;
using System;
namespace WebsitePanel.Portal
{
public class VirtualMachines2012Helper
{
public static bool IsVirtualMachineManagementAllowed(int packageId)
{
bool manageAllowed = false;
PackageContext cntx = PackagesHelper.GetCachedPackageContext(packageId);
if (cntx.Quotas.ContainsKey(Quotas.VPS2012_MANAGING_ALLOWED))
manageAllowed = !cntx.Quotas[Quotas.VPS2012_MANAGING_ALLOWED].QuotaExhausted;
if (PanelSecurity.EffectiveUser.Role == UserRole.Administrator)
manageAllowed = true;
else if (PanelSecurity.EffectiveUser.Role == UserRole.Reseller)
{
// check if the reseller is allowed to manage on its parent level
PackageInfo package = ES.Services.Packages.GetPackage(PanelSecurity.PackageId);
if (package.UserId != PanelSecurity.EffectiveUserId)
{
cntx = PackagesHelper.GetCachedPackageContext(package.ParentPackageId);
if (cntx != null && cntx.Quotas.ContainsKey(Quotas.VPS2012_MANAGING_ALLOWED))
manageAllowed = !cntx.Quotas[Quotas.VPS2012_MANAGING_ALLOWED].QuotaExhausted;
}
}
return manageAllowed;
}
// TODO: Move this method to the corresponding extension later.
public static VirtualMachine GetCachedVirtualMachine(int itemId)
{
return VirtualMachinesExtensions.GetCachedVirtualMachine<VirtualMachine>(
itemId, () => ES.Services.VPS2012.GetVirtualMachineItem(itemId));
}
#region Virtual Machines
VirtualMachineMetaItemsPaged vms;
public VirtualMachineMetaItem[] GetVirtualMachines(int packageId, string filterColumn, string filterValue,
string sortColumn, int maximumRows, int startRowIndex)
{
vms = ES.Services.VPS2012.GetVirtualMachines(packageId, filterColumn, filterValue,
sortColumn, startRowIndex, maximumRows, true);
return vms.Items;
}
public int GetVirtualMachinesCount(int packageId, string filterColumn, string filterValue)
{
return vms.Count;
}
#endregion
#region Package IP Addresses
PackageIPAddressesPaged packageAddresses;
public PackageIPAddress[] GetPackageIPAddresses(int packageId, IPAddressPool pool, string filterColumn, string filterValue,
string sortColumn, int maximumRows, int startRowIndex)
{
packageAddresses = ES.Services.Servers.GetPackageIPAddresses(packageId, 0, pool,
filterColumn, filterValue, sortColumn, startRowIndex, maximumRows, true);
return packageAddresses.Items;
}
public int GetPackageIPAddressesCount(int packageId, IPAddressPool pool, string filterColumn, string filterValue)
{
return packageAddresses.Count;
}
public PackageIPAddress[] GetPackageIPAddresses(int packageId, int orgId, IPAddressPool pool, string filterColumn, string filterValue,
string sortColumn, int maximumRows, int startRowIndex)
{
packageAddresses = ES.Services.Servers.GetPackageIPAddresses(packageId, orgId, pool,
filterColumn, filterValue, sortColumn, startRowIndex, maximumRows, true);
return packageAddresses.Items;
}
public int GetPackageIPAddressesCount(int packageId, int orgId, IPAddressPool pool, string filterColumn, string filterValue)
{
return packageAddresses.Count;
}
#endregion
#region Package Private IP Addresses
PrivateIPAddressesPaged privateAddresses;
public PrivateIPAddress[] GetPackagePrivateIPAddresses(int packageId, string filterColumn, string filterValue,
string sortColumn, int maximumRows, int startRowIndex)
{
privateAddresses = ES.Services.VPS2012.GetPackagePrivateIPAddressesPaged(packageId, filterColumn, filterValue,
sortColumn, startRowIndex, maximumRows);
return privateAddresses.Items;
}
public int GetPackagePrivateIPAddressesCount(int packageId, string filterColumn, string filterValue)
{
return privateAddresses.Count;
}
#endregion
}
}

29
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/Code/ProviderControls/IVirtualMachineCreateControl.cs → WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/Code/ProviderControls/IVirtualMachineSettingsControl.cs
View file

@ -26,27 +26,24 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Collections.Generic;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using WebsitePanel.Providers.Mail;
using WebsitePanel.Providers.Virtualization;
namespace WebsitePanel.Portal
{
/// <summary>
/// Summary description for IVirtualMachineCreateControl
/// </summary>
public interface IVirtualMachineCreateControl
public enum VirtualMachineSettingsMode
{
void BindItem(VirtualMachine item);
void SaveItem(VirtualMachine item);
Display,
Edit,
Summary,
}
public interface IVirtualMachineSettingsControl
{
VirtualMachineSettingsMode Mode { get; set; }
void BindItem(VirtualMachine item);
void SaveItem(ref VirtualMachine item);
}
}

2
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/ExchangeServer/App_LocalResources/OrganizationHome.ascx.resx
View file

@ -238,6 +238,6 @@
<value>RDS Users</value>
</data>
<data name="locSharePointEnterprise.Text" xml:space="preserve">
<value>SharePoint Enterprise</value>
<value>SharePoint Server</value>
</data>
</root>

20
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/Login.ascx.cs
View file

@ -233,6 +233,26 @@ namespace WebsitePanel.Portal
}
}
if (cntx.Groups.ContainsKey(ResourceGroups.VPS2012))
{
// VPS resource found
// check created VPS
VirtualMachineMetaItemsPaged vms = ES.Services.VPS2012.GetVirtualMachines(packageId, "", "", "", 0, Int32.MaxValue, false);
if (vms.Items.Length == 1)
{
// one VPS - redirect to its properties screen
Response.Redirect(PortalUtils.NavigatePageURL("SpaceVPS2012", "SpaceID", packageId.ToString(),
"ItemID=" + vms.Items[0].ItemID.ToString(), "ctl=vps_general", "moduleDefId=VPS2012"));
}
else
{
// several VPS - redirect to VPS list page
Response.Redirect(PortalUtils.NavigatePageURL("SpaceVPS2012", "SpaceID", packageId.ToString(),
"ctl=", "moduleDefId=VPS2012"));
}
}
if (cntx.Groups.ContainsKey(ResourceGroups.VPSForPC))
{

6
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/RDSServers.ascx
View file

@ -63,10 +63,10 @@
</ItemTemplate>
</asp:TemplateField>
<asp:BoundField DataField="Address" HeaderText="IP Address"><ItemStyle Width="10%"/></asp:BoundField>
<asp:BoundField DataField="ItemName" HeaderText="Organization"><ItemStyle Width="10%"/></asp:BoundField>
<asp:BoundField DataField="Description" HeaderText="Comments"><ItemStyle Width="20%"/></asp:BoundField>
<asp:BoundField DataField="ItemName" HeaderText="Organization"><ItemStyle Width="20%"/></asp:BoundField>
<asp:BoundField DataField="Description" HeaderText="Comments"><ItemStyle Width="15%"/></asp:BoundField>
<asp:TemplateField meta:resourcekey="gvPopupStatus">
<ItemStyle Width="20%" HorizontalAlign="Left" />
<ItemStyle Width="15%" HorizontalAlign="Left" />
<ItemTemplate>
<asp:Literal ID="litStatus" runat="server" Text='<%# Eval("Status") %>'></asp:Literal>
<asp:HiddenField ID="hdnRdsCollectionId" runat="server" Value='<%# Eval("RdsCollectionId") %>' />

1
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/ServersEditService.ascx.cs
View file

@ -177,6 +177,7 @@ namespace WebsitePanel.Portal
(resourceGroup.GroupName == ResourceGroups.MySql5)|
(resourceGroup.GroupName == ResourceGroups.Statistics)|
(resourceGroup.GroupName == ResourceGroups.VPS)|
(resourceGroup.GroupName == ResourceGroups.VPS2012)|
(resourceGroup.GroupName == ResourceGroups.VPSForPC));
}

10
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/SpaceQuotas.ascx
View file

@ -71,13 +71,13 @@
<td class="Normal"><wsp:Quota ID="quotaBlackBerryUsers" runat="server" QuotaName="BlackBerry.Users" DisplayGauge="True" /></td>
</tr>
<tr ID="pnlSharepointSites" runat="server">
<td class="SubHead" nowrap><asp:Label ID="lblSharepointSites" runat="server" meta:resourcekey="lblSharepointSites" Text="Sharepoint Sites:"></asp:Label></td>
<td class="SubHead" nowrap><asp:Label ID="lblSharepointSites" runat="server" meta:resourcekey="lblSharepointSites" Text="Sharepoint Foundation Sites:"></asp:Label></td>
<td class="Normal"><wsp:Quota ID="quotaSharepointSites" runat="server" QuotaName="HostedSharePoint.Sites" DisplayGauge="True" /></td>
</tr>
<tr ID="pnlSharepointEnterpriseSites" runat="server">
<td class="SubHead" nowrap><asp:Label ID="Label2" runat="server" meta:resourcekey="lblSharepointEnterpriseSites" Text="Sharepoint Enterprise Sites:"></asp:Label></td>
<td class="Normal"><wsp:Quota ID="quotaSharepointEnterpriseSites" runat="server" QuotaName="HostedSharePointEnterprise.Sites" DisplayGauge="True" /></td>
</tr>
<tr ID="pnlEnterpriseSharepointSites" runat="server">
<td class="SubHead" nowrap><asp:Label ID="lblEnterpriseSharepointSites" runat="server" meta:resourcekey="lblEnterpriseSharepointSites" Text="Sharepoint Server Sites:"></asp:Label></td>
<td class="Normal"><wsp:Quota ID="quotaEnterpriseSharepointSites" runat="server" QuotaName="HostedSharePointEnterprise.Sites" DisplayGauge="True" /></td>
</tr>
<tr ID="pnlWebSites" runat="server">
<td class="SubHead" nowrap><asp:Label ID="lblWebSites" runat="server" meta:resourcekey="lblWebSites" Text="Web Sites:"></asp:Label></td>

6
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/SpaceQuotas.ascx.cs
View file

@ -66,15 +66,15 @@ namespace WebsitePanel.Portal
{ "quotaOCSUsers", "pnlOCSUsers" },
{ "quotaLyncUsers", "pnlLyncUsers" },
{ "quotaBlackBerryUsers", "pnlBlackBerryUsers" },
{ "quotaSharepointSites", "pnlSharepointSites" },
{ "quotaSharepointEnterpriseSites", "pnlSharepointEnterpriseSites" },
{ "quotaSharepointSites", "pnlSharepointSites" },
{ "quotaWebSites", "pnlWebSites" },
{ "quotaDatabases", "pnlDatabases" },
{ "quotaNumberOfVm", "pnlHyperVForPC" },
{ "quotaFtpAccounts", "pnlFtpAccounts" },
{ "quotaExchangeStorage", "pnlExchangeStorage" },
{ "quotaNumberOfFolders", "pnlFolders" },
{ "quotaEnterpriseStorage", "pnlEnterpriseStorage" }
{ "quotaEnterpriseStorage", "pnlEnterpriseStorage" },
{ "quotaEnterpriseSharepointSites", "pnlEnterpriseSharepointSites"}
};
protected void Page_Load(object sender, EventArgs e)

12
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/SpaceQuotas.ascx.designer.cs generated
View file

@ -427,31 +427,31 @@ namespace WebsitePanel.Portal {
protected global::WebsitePanel.Portal.Quota quotaSharepointSites;
/// <summary>
/// pnlSharepointEnterpriseSites control.
/// pnlEnterpriseSharepointSites control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.HtmlControls.HtmlTableRow pnlSharepointEnterpriseSites;
protected global::System.Web.UI.HtmlControls.HtmlTableRow pnlEnterpriseSharepointSites;
/// <summary>
/// Label2 control.
/// lblEnterpriseSharepointSites control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.WebControls.Label Label2;
protected global::System.Web.UI.WebControls.Label lblEnterpriseSharepointSites;
/// <summary>
/// quotaSharepointEnterpriseSites control.
/// quotaEnterpriseSharepointSites control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::WebsitePanel.Portal.Quota quotaSharepointEnterpriseSites;
protected global::WebsitePanel.Portal.Quota quotaEnterpriseSharepointSites;
/// <summary>
/// pnlWebSites control.

3
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/SpaceSettings.ascx
View file

@ -27,6 +27,9 @@
<div class="ToolLink">
<asp:HyperLink ID="lnkVps" runat="server" meta:resourcekey="lnkVps" Text="Virtual Private Servers"></asp:HyperLink>
</div>
<div class="ToolLink">
<asp:HyperLink ID="lnkVps2012" runat="server" meta:resourcekey="lnkVps2012" Text="Virtual Private Servers 2012"></asp:HyperLink>
</div>
<div class="ToolLink">
<asp:HyperLink ID="lnkVpsForPC" runat="server" meta:resourcekey="lnkVpsForPC" Text="Virtual Private Servers for Private Cloud"></asp:HyperLink>
</div>

2
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/SpaceSettings.ascx.cs
View file

@ -61,6 +61,8 @@ namespace WebsitePanel.Portal
"edit_settings", "SettingsName=ExchangeServer", "SpaceID=" + PanelSecurity.PackageId.ToString());
lnkVps.NavigateUrl = EditUrl("SettingsControl", "SpaceSettingsVPS",
"edit_settings", "SettingsName=VirtualPrivateServers", "SpaceID=" + PanelSecurity.PackageId.ToString());
lnkVps2012.NavigateUrl = EditUrl("SettingsControl", "SpaceSettingsVPS2012",
"edit_settings", "SettingsName=VirtualPrivateServers2012", "SpaceID=" + PanelSecurity.PackageId.ToString());
lnkVpsForPC.NavigateUrl = EditUrl("SettingsControl", "SpaceSettingsVPSForPC",
"edit_settings", "SettingsName=VirtualPrivateServersForPrivateCloud", "SpaceID=" + PanelSecurity.PackageId.ToString());

37
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/SpaceSettings.ascx.designer.cs generated
View file

@ -1,31 +1,3 @@
// Copyright (c) 2015, Outercurve Foundation.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// - Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// - Neither the name of the Outercurve Foundation nor the names of its
// contributors may be used to endorse or promote products derived from this
// software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
@ -121,6 +93,15 @@ namespace WebsitePanel.Portal {
/// </remarks>
protected global::System.Web.UI.WebControls.HyperLink lnkVps;
/// <summary>
/// lnkVps2012 control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.WebControls.HyperLink lnkVps2012;
/// <summary>
/// lnkVpsForPC control.
/// </summary>

8
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/UserControls/AllocatePackageIPAddresses.ascx.cs
View file

@ -90,7 +90,13 @@ namespace WebsitePanel.Portal.UserControls
}
int quotaAllowed = -1;
string quotaName = (String.Compare(ResourceGroup, ResourceGroups.VPS, true) == 0) ? Quotas.VPS_EXTERNAL_IP_ADDRESSES_NUMBER : Quotas.WEB_IP_ADDRESSES;
string quotaName = Quotas.WEB_IP_ADDRESSES;
if (String.Compare(ResourceGroup, ResourceGroups.VPS, StringComparison.OrdinalIgnoreCase) == 0)
quotaName = Quotas.VPS_EXTERNAL_IP_ADDRESSES_NUMBER;
else if (String.Compare(ResourceGroup, ResourceGroups.VPS2012, StringComparison.OrdinalIgnoreCase) == 0)
quotaName = Quotas.VPS2012_EXTERNAL_IP_ADDRESSES_NUMBER;
PackageContext cntx = PackagesHelper.GetCachedPackageContext(PanelSecurity.PackageId);
if (cntx.Quotas.ContainsKey(quotaName))
{

7
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/App_LocalResources/VdcCreateServer.ascx.resx
View file

@ -112,10 +112,10 @@
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnFinish.Text" xml:space="preserve">
<value>Create</value>
@ -369,4 +369,7 @@
<data name="valNewDomainFormat.ErrorMessage" xml:space="preserve">
<value>Enter correct domain name, for example "mydomain.com"</value>
</data>
<data name="locGeneration.Text" xml:space="preserve">
<value>Generation:</value>
</data>
</root>

12
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/ProviderControls/App_LocalResources/HyperV2012R2_Create.ascx.resx
View file

@ -117,16 +117,4 @@
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="ddlGenerationItem.1" xml:space="preserve">
<value>First</value>
</data>
<data name="ddlGenerationItem.2" xml:space="preserve">
<value>Second</value>
</data>
<data name="locGeneration.Text" xml:space="preserve">
<value>Generation:</value>
</data>
<data name="secGeneration.Text" xml:space="preserve">
<value>Generation</value>
</data>
</root>

120
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/ProviderControls/App_LocalResources/HyperV2012R2_Edit.ascx.resx Normal file
View file

@ -0,0 +1,120 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
</root>

22
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/ProviderControls/HyperV2012R2_Create.ascx
View file

@ -1,20 +1,6 @@
<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="HyperV2012R2_Create.ascx.cs" Inherits="WebsitePanel.Portal.ProviderControls.HyperV2012R2_Create" %>
<%@ Register TagPrefix="wsp" TagName="CollapsiblePanel" Src="../../UserControls/CollapsiblePanel.ascx" %>
<%@ Register TagPrefix="wsp" TagName="Generation" Src="../UserControls/Generation.ascx" %>
<%@ Register TagPrefix="wsp" TagName="DynamicMemory" Src="../UserControls/DynamicMemory.ascx" %>
<wsp:CollapsiblePanel id="secGeneration" runat="server" TargetControlID="GenerationPanel" meta:resourcekey="secGeneration" Text="Generation">
</wsp:CollapsiblePanel>
<asp:Panel ID="GenerationPanel" runat="server" Height="0" Style="overflow: hidden; padding: 5px;">
<table>
<tr>
<td class="FormLabel150">
<asp:Localize ID="locGeneration" runat="server"
meta:resourcekey="locGeneration" Text="Generation:"></asp:Localize></td>
<td>
<asp:DropDownList ID="ddlGeneration" runat="server" CssClass="NormalTextBox" resourcekey="ddlGeneration">
<asp:ListItem Value="1">1</asp:ListItem>
<asp:ListItem Value="2">2</asp:ListItem>
</asp:DropDownList>
</td>
</tr>
</table>
</asp:Panel>
<wsp:Generation runat="server" ID="GenerationSetting"></wsp:Generation>
<wsp:DynamicMemory runat="server" ID="DynamicMemorySetting"></wsp:DynamicMemory>

34
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/ProviderControls/HyperV2012R2_Create.ascx.cs
View file

@ -27,25 +27,51 @@
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.UI;
using WebsitePanel.Providers.Virtualization;
namespace WebsitePanel.Portal.ProviderControls
{
public partial class HyperV2012R2_Create : WebsitePanelControlBase, IVirtualMachineCreateControl
public partial class HyperV2012R2_Create : WebsitePanelControlBase, IVirtualMachineSettingsControl
{
private bool _isEditMode;
protected void Page_Load(object sender, EventArgs e)
{
}
public bool IsEditMode
{
get { return _isEditMode; }
set
{
_isEditMode = value;
SettingContols.ForEach(s=>s.IsEditMode = _isEditMode);
}
}
public void BindItem(VirtualMachine item)
{
var generation = item.Generation > 1 ? item.Generation : 1;
ddlGeneration.SelectedValue = generation.ToString();
SettingContols.ForEach(s => s.BindItem(item));
}
public void SaveItem(VirtualMachine item)
{
item.Generation = Convert.ToInt32(ddlGeneration.SelectedValue);
SettingContols.ForEach(s => s.SaveItem(item));
}
private List<IVirtualMachineSettingsControl> SettingContols
{
get
{
return Controls
.Cast<Control>()
.Where(c => c is IVirtualMachineSettingsControl)
.Cast<IVirtualMachineSettingsControl>()
.ToList();
}
}
}
}

26
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/ProviderControls/HyperV2012R2_Create.ascx.designer.cs generated
View file

@ -13,39 +13,21 @@ namespace WebsitePanel.Portal.ProviderControls {
public partial class HyperV2012R2_Create {
/// <summary>
/// secGeneration control.
/// GenerationSetting control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::WebsitePanel.Portal.CollapsiblePanel secGeneration;
protected global::WebsitePanel.Portal.VPS.UserControls.Generation GenerationSetting;
/// <summary>
/// GenerationPanel control.
/// DynamicMemorySetting control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.WebControls.Panel GenerationPanel;
/// <summary>
/// locGeneration control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.WebControls.Localize locGeneration;
/// <summary>
/// ddlGeneration control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.WebControls.DropDownList ddlGeneration;
protected global::WebsitePanel.Portal.VPS.UserControls.DynamicMemory DynamicMemorySetting;
}
}

4
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/ProviderControls/HyperV2012R2_Edit.ascx Normal file
View file

@ -0,0 +1,4 @@
<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="HyperV2012R2_Edit.ascx.cs" Inherits="WebsitePanel.Portal.ProviderControls.HyperV2012R2_Edit" %>
<%@ Register TagPrefix="wsp" TagName="DynamicMemory" Src="../UserControls/DynamicMemory.ascx" %>
<wsp:DynamicMemory runat="server" ID="DynamicMemorySetting"></wsp:DynamicMemory>

52
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/ProviderControls/HyperV2012R2_Edit.ascx.cs Normal file
View file

@ -0,0 +1,52 @@
// Copyright (c) 2015, Outercurve Foundation.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// - Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// - Neither the name of the Outercurve Foundation nor the names of its
// contributors may be used to endorse or promote products derived from this
// software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using System;
using WebsitePanel.Providers.Virtualization;
namespace WebsitePanel.Portal.ProviderControls
{
public partial class HyperV2012R2_Edit : WebsitePanelControlBase, IVirtualMachineSettingsControl
{
protected void Page_Load(object sender, EventArgs e)
{
}
public bool IsEditMode { get; set; }
public void BindItem(VirtualMachine item)
{
DynamicMemorySetting.BindItem(item);
}
public void SaveItem(VirtualMachine item)
{
DynamicMemorySetting.SaveItem(item);
}
}
}

24
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/ProviderControls/HyperV2012R2_Edit.ascx.designer.cs generated Normal file
View file

@ -0,0 +1,24 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace WebsitePanel.Portal.ProviderControls {
public partial class HyperV2012R2_Edit {
/// <summary>
/// DynamicMemorySetting control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::WebsitePanel.Portal.VPS.UserControls.DynamicMemory DynamicMemorySetting;
}
}

126
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/UserControls/App_LocalResources/DynamicMemory.ascx.resx Normal file
View file

@ -0,0 +1,126 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="locDymanicMemory.Text" xml:space="preserve">
<value>Dymanic memory:</value>
</data>
<data name="secDymanicMemory.Text" xml:space="preserve">
<value>Dymanic memory</value>
</data>
</root>

132
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/UserControls/App_LocalResources/Generation.ascx.resx Normal file
View file

@ -0,0 +1,132 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="ddlGenerationItem.1" xml:space="preserve">
<value>First</value>
</data>
<data name="ddlGenerationItem.2" xml:space="preserve">
<value>Second</value>
</data>
<data name="locGeneration.Text" xml:space="preserve">
<value>Generation:</value>
</data>
<data name="secGeneration.Text" xml:space="preserve">
<value>Generation</value>
</data>
</root>

17
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/UserControls/DynamicMemory.ascx Normal file
View file

@ -0,0 +1,17 @@
<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="DynamicMemory.ascx.cs" Inherits="WebsitePanel.Portal.VPS.UserControls.DynamicMemory" %>
<%@ Register TagPrefix="wsp" TagName="CollapsiblePanel" Src="../../UserControls/CollapsiblePanel.ascx" %>
<wsp:CollapsiblePanel id="secDymanicMemory" runat="server" TargetControlID="DymanicMemoryPanel" meta:resourcekey="secDymanicMemory" Text="Dymanic memory">
</wsp:CollapsiblePanel>
<asp:Panel ID="DymanicMemoryPanel" runat="server" Height="0" Style="overflow: hidden; padding: 5px;">
<table>
<tr>
<td class="FormLabel150">
<asp:Localize ID="locDymanicMemory" runat="server"
meta:resourcekey="locDymanicMemory" Text="Dymanic Memory:"></asp:Localize></td>
<td>
</td>
</tr>
</table>
</asp:Panel>

50
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/UserControls/DynamicMemory.ascx.cs Normal file
View file

@ -0,0 +1,50 @@
// Copyright (c) 2015, Outercurve Foundation.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// - Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// - Neither the name of the Outercurve Foundation nor the names of its
// contributors may be used to endorse or promote products derived from this
// software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using System;
using WebsitePanel.Providers.Virtualization;
namespace WebsitePanel.Portal.VPS.UserControls
{
public partial class DynamicMemory : WebsitePanelControlBase, IVirtualMachineSettingsControl
{
protected void Page_Load(object sender, EventArgs e)
{
}
public bool IsEditMode { get; set; }
public void BindItem(VirtualMachine item)
{
}
public void SaveItem(VirtualMachine item)
{
}
}
}

42
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/UserControls/DynamicMemory.ascx.designer.cs generated Normal file
View file

@ -0,0 +1,42 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace WebsitePanel.Portal.VPS.UserControls {
public partial class DynamicMemory {
/// <summary>
/// secDymanicMemory control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::WebsitePanel.Portal.CollapsiblePanel secDymanicMemory;
/// <summary>
/// DymanicMemoryPanel control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.WebControls.Panel DymanicMemoryPanel;
/// <summary>
/// locDymanicMemory control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.WebControls.Localize locDymanicMemory;
}
}

24
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/UserControls/Generation.ascx Normal file
View file

@ -0,0 +1,24 @@
<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="Generation.ascx.cs" Inherits="WebsitePanel.Portal.VPS.UserControls.Generation" %>
<%@ Register TagPrefix="wsp" TagName="CollapsiblePanel" Src="../../UserControls/CollapsiblePanel.ascx" %>
<wsp:CollapsiblePanel ID="secGeneration" runat="server" TargetControlID="GenerationPanel" meta:ResourceKey="secGeneration" Text="Generation"></wsp:CollapsiblePanel>
<asp:Panel ID="GenerationPanel" runat="server" Height="0" Style="overflow: hidden; padding: 5px;">
<table>
<tr>
<td class="FormLabel150">
<asp:Localize ID="locGeneration" runat="server" meta:resourcekey="locGeneration" Text="Generation:"></asp:Localize>
</td>
<td>
<% if (IsEditMode)
{ %>
<asp:DropDownList ID="ddlGeneration" runat="server" CssClass="NormalTextBox" resourcekey="ddlGeneration">
<asp:ListItem Value="1">1</asp:ListItem>
<asp:ListItem Value="2">2</asp:ListItem>
</asp:DropDownList>
<% } else { %>
<asp:Label runat="server" ID="lblGeneration"/>
<% } %>
</td>
</tr>
</table>
</asp:Panel>

54
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/UserControls/Generation.ascx.cs Normal file
View file

@ -0,0 +1,54 @@
// Copyright (c) 2015, Outercurve Foundation.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// - Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// - Neither the name of the Outercurve Foundation nor the names of its
// contributors may be used to endorse or promote products derived from this
// software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using System;
using WebsitePanel.Providers.Virtualization;
namespace WebsitePanel.Portal.VPS.UserControls
{
public partial class Generation : WebsitePanelControlBase, IVirtualMachineSettingsControl
{
protected void Page_Load(object sender, EventArgs e)
{
}
public bool IsEditMode { get; set; }
public void BindItem(VirtualMachine item)
{
var generation = item.Generation > 1 ? item.Generation : 1;
ddlGeneration.SelectedValue = generation.ToString();
lblGeneration.Text = generation.ToString();
}
public void SaveItem(VirtualMachine item)
{
item.Generation = Convert.ToInt32(ddlGeneration.SelectedValue);
}
}
}

60
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/UserControls/Generation.ascx.designer.cs generated Normal file
View file

@ -0,0 +1,60 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace WebsitePanel.Portal.VPS.UserControls {
public partial class Generation {
/// <summary>
/// secGeneration control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::WebsitePanel.Portal.CollapsiblePanel secGeneration;
/// <summary>
/// GenerationPanel control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.WebControls.Panel GenerationPanel;
/// <summary>
/// locGeneration control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.WebControls.Localize locGeneration;
/// <summary>
/// ddlGeneration control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.WebControls.DropDownList ddlGeneration;
/// <summary>
/// lblGeneration control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.WebControls.Label lblGeneration;
}
}

2
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/VdcCreateServer.ascx
View file

@ -188,8 +188,6 @@
</tr>
</table>
</asp:Panel>
<asp:PlaceHolder ID="providerControl" runat="server"></asp:PlaceHolder>
<wsp:CollapsiblePanel id="secSnapshots" runat="server"
TargetControlID="SnapshotsPanel" meta:resourcekey="secSnapshots" Text="Snapshots">

46
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/VdcCreateServer.ascx.cs
View file

@ -1,4 +1,4 @@
// Copyright (c) 2015, Outercurve Foundation.
// Copyright (c) 2015, Outercurve Foundation.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
@ -26,7 +26,7 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using System;
using System;
using System.Collections.Generic;
using System.Web;
using System.Web.UI;
@ -42,8 +42,6 @@ namespace WebsitePanel.Portal.VPS
{
protected void Page_Load(object sender, EventArgs e)
{
LoadCustomProviderControl();
if (!IsPostBack)
{
BindFormControls();
@ -55,27 +53,7 @@ namespace WebsitePanel.Portal.VPS
// toggle
ToggleControls();
}
private void LoadCustomProviderControl()
{
try
{
LoadProviderControl(PanelSecurity.PackageId, "VPS", providerControl, "Create.ascx");
}
catch { /* skip */ }
}
private IVirtualMachineCreateControl CustomProviderControl
{
get
{
if (providerControl.Controls.Count == 0)
return null;
return (IVirtualMachineCreateControl)providerControl.Controls[0];
}
}
private void ToggleWizardSteps()
{
// external network
@ -135,13 +113,6 @@ namespace WebsitePanel.Portal.VPS
ddlCpu.SelectedIndex = ddlCpu.Items.Count - 1; // select last (maximum) item
// the custom provider control
if (CustomProviderControl != null)
{
IVirtualMachineCreateControl ctrl = (IVirtualMachineCreateControl)providerControl.Controls[0];
ctrl.BindItem(new VirtualMachine());
}
// external network details
if (PackagesHelper.IsQuotaEnabled(PanelSecurity.PackageId, Quotas.VPS_EXTERNAL_NETWORK_ENABLED))
{
@ -316,15 +287,6 @@ namespace WebsitePanel.Portal.VPS
try
{
VirtualMachine virtualMachine = new VirtualMachine();
// the custom provider control
if (CustomProviderControl != null)
{
IVirtualMachineCreateControl ctrl = (IVirtualMachineCreateControl)providerControl.Controls[0];
ctrl.SaveItem(virtualMachine);
}
// collect and prepare data
string hostname = String.Format("{0}.{1}", txtHostname.Text.Trim(), txtDomain.Text.Trim());
@ -343,7 +305,7 @@ namespace WebsitePanel.Portal.VPS
// create virtual machine
IntResult res = ES.Services.VPS.CreateVirtualMachine(PanelSecurity.PackageId,
hostname, listOperatingSystems.SelectedValue, adminPassword, summaryEmail,
virtualMachine.Generation, Utils.ParseInt(ddlCpu.SelectedValue), Utils.ParseInt(txtRam.Text.Trim()),
1, Utils.ParseInt(ddlCpu.SelectedValue), Utils.ParseInt(txtRam.Text.Trim()),
Utils.ParseInt(txtHdd.Text.Trim()), Utils.ParseInt(txtSnapshots.Text.Trim()),
chkDvdInstalled.Checked, chkBootFromCd.Checked, chkNumLock.Checked,
chkStartShutdown.Checked, chkPauseResume.Checked, chkReboot.Checked, chkReset.Checked, chkReinstall.Checked,

9
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/VdcCreateServer.ascx.designer.cs generated
View file

@ -372,15 +372,6 @@ namespace WebsitePanel.Portal.VPS {
/// </remarks>
protected global::System.Web.UI.WebControls.Localize locGB;
/// <summary>
/// providerControl control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.WebControls.PlaceHolder providerControl;
/// <summary>
/// secSnapshots control.
/// </summary>

3
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/VpsDetailsEditConfiguration.ascx.cs
View file

@ -96,9 +96,6 @@ namespace WebsitePanel.Portal.VPS
chkExternalNetworkEnabled.Checked = vm.ExternalNetworkEnabled;
chkPrivateNetworkEnabled.Checked = vm.PrivateNetworkEnabled;
// toggle controls
// other quotas
BindCheckboxOption(chkDvdInstalled, Quotas.VPS_DVD_ENABLED);
chkBootFromCd.Enabled = PackagesHelper.IsQuotaEnabled(PanelSecurity.PackageId, Quotas.VPS_BOOT_CD_ALLOWED);

40
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS/VpsDetailsEditConfiguration.ascx.designer.cs generated
View file

@ -1,38 +1,9 @@
// Copyright (c) 2015, Outercurve Foundation.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// - Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// - Neither the name of the Outercurve Foundation nor the names of its
// contributors may be used to endorse or promote products derived from this
// software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:2.0.50727.1434
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
@ -463,14 +434,5 @@ namespace WebsitePanel.Portal.VPS {
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.WebControls.Button btnCancel;
/// <summary>
/// FormComments control.
/// </summary>
/// <remarks>
/// Auto-generated field.
/// To modify move field declaration from designer file to code-behind file.
/// </remarks>
protected global::System.Web.UI.WebControls.Localize FormComments;
}
}

126
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VdcAddExternalAddress.ascx.resx Normal file
View file

@ -0,0 +1,126 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;The form allows allocating of additional External IP addresses to this hosting space. These IP addresses are used to configure VPS network adapter connected to External network.&lt;/p&gt;&lt;p&gt;VPS module is looking for free external IP addresses in "VPS External Network" pool, so WebsitePanel administrator must make sure there are sufficient number of unallotted IP addresses in that pool.&lt;/p&gt;</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Allocate IP Addresses</value>
</data>
</root>

126
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VdcAuditLog.ascx.resx Normal file
View file

@ -0,0 +1,126 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;Audit log displays the chronology of events for all VPS located in the hosting space.&lt;/p&gt;&lt;p&gt;By default audit log displays all today's events. You may filter the log by date (day, week, month), severity, task and item name (VPS host name).&lt;/p&gt;&lt;p&gt;To see task details click the link with task name in "Task" column.&lt;/p&gt;&lt;p&gt;To export log in CSV format click "Export Log" button.&lt;/p&gt;</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Audit Log</value>
</data>
</root>

378
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VdcCreateServer.ascx.resx Normal file
View file

@ -0,0 +1,378 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnFinish.Text" xml:space="preserve">
<value>Create</value>
</data>
<data name="btnNext.Text" xml:space="preserve">
<value>Next &gt;</value>
</data>
<data name="btnPrevious.Text" xml:space="preserve">
<value>&lt; Back</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;&lt;b&gt;Welcome to VPS Creation Wizard!&lt;/b&gt;&lt;/p&gt;&lt;p&gt;The wizard allows specifying parameters of new VPS such as host name, operating system template, administrator password, External and Private (if allowed in the hosting plan) network parameters.&lt;/p&gt;&lt;p&gt;If e-mail address is specified in "Send summary letter to" then VPS summary information will be sent on that e-mail upon provisioning process completion.&lt;/p&gt;&lt;p&gt;After clicking "Create" button on the last step of the wizard the process of provisioning a new VPS will be started. The process is asynchronous, so it's not necessary to wait until it's finished.&lt;/p&gt;</value>
</data>
<data name="stepConfig.Title" xml:space="preserve">
<value>Configuration</value>
</data>
<data name="stepExternalNetwork.Title" xml:space="preserve">
<value>External Network</value>
</data>
<data name="stepName.Title" xml:space="preserve">
<value>Name &amp; OS</value>
</data>
<data name="stepPrivateNetwork.Title" xml:space="preserve">
<value>Private Network</value>
</data>
<data name="stepSummary.Title" xml:space="preserve">
<value>Summary</value>
</data>
<data name="DomainValidator.ErrorMessage" xml:space="preserve">
<value>Enter domain name</value>
</data>
<data name="ExternalAddressesValidator.ErrorMessage" xml:space="preserve">
<value>Enter the number of external IP addresses</value>
</data>
<data name="HostnameValidator.ErrorMessage" xml:space="preserve">
<value>Enter host name</value>
</data>
<data name="PrivateAddressesValidator.ErrorMessage" xml:space="preserve">
<value>Enter the number of private IP addresses</value>
</data>
<data name="RequireHddValidator.ErrorMessage" xml:space="preserve">
<value>Enter the size of hard disk drive</value>
</data>
<data name="RequireRamValidator.ErrorMessage" xml:space="preserve">
<value>Enter amount of RAM allocated to new VPS</value>
</data>
<data name="SnapshotsValidator.ErrorMessage" xml:space="preserve">
<value>Enter the maximum number of snapshots</value>
</data>
<data name="SummaryEmailValidator.ErrorMessage" xml:space="preserve">
<value>Enter e-mail address to send summary letter</value>
</data>
<data name="chkBootFromCd.Text" xml:space="preserve">
<value>Boot from CD</value>
</data>
<data name="chkDvdInstalled.Text" xml:space="preserve">
<value>DVD drive installed</value>
</data>
<data name="chkExternalNetworkEnabled.Text" xml:space="preserve">
<value>External network enabled</value>
</data>
<data name="chkNumLock.Text" xml:space="preserve">
<value>"Num Lock" enabled</value>
</data>
<data name="chkPauseResume.Text" xml:space="preserve">
<value>Pause, Resume</value>
</data>
<data name="chkPrivateNetworkEnabled.Text" xml:space="preserve">
<value>Private network enabled</value>
</data>
<data name="chkReboot.Text" xml:space="preserve">
<value>Reboot</value>
</data>
<data name="chkReinstall.Text" xml:space="preserve">
<value>Re-install</value>
</data>
<data name="chkReset.Text" xml:space="preserve">
<value>Reset</value>
</data>
<data name="chkSendSummary.Text" xml:space="preserve">
<value>Send summary e-mail to:</value>
</data>
<data name="chkStartShutdown.Text" xml:space="preserve">
<value>Start, Turn off and Shutdown</value>
</data>
<data name="lblCpu.Text" xml:space="preserve">
<value>CPU:</value>
</data>
<data name="lblHdd.Text" xml:space="preserve">
<value>HDD:</value>
</data>
<data name="lblRam.Text" xml:space="preserve">
<value>RAM:</value>
</data>
<data name="locAdminPassword.Text" xml:space="preserve">
<value>Administrator password:</value>
</data>
<data name="locBootFromCd.Text" xml:space="preserve">
<value>Boot from CD:</value>
</data>
<data name="locConfigStepTitle.Text" xml:space="preserve">
<value>Configuration</value>
</data>
<data name="locCores.Text" xml:space="preserve">
<value>cores</value>
</data>
<data name="locCpu.Text" xml:space="preserve">
<value>CPU cores:</value>
</data>
<data name="locDvdInstalled.Text" xml:space="preserve">
<value>DVD Drive installed:</value>
</data>
<data name="locExternalAddresses.Text" xml:space="preserve">
<value>Number of IP addresses:</value>
</data>
<data name="locExternalAddressesList.Text" xml:space="preserve">
<value>IP addresses list:</value>
</data>
<data name="locExternalAddressesNumber.Text" xml:space="preserve">
<value>Number of IP addresses:</value>
</data>
<data name="locExternalNetwork.Text" xml:space="preserve">
<value>External Network</value>
</data>
<data name="locExternalNetworkEnabled.Text" xml:space="preserve">
<value>External network enabled:</value>
</data>
<data name="locGB.Text" xml:space="preserve">
<value>GB</value>
</data>
<data name="locHdd.Text" xml:space="preserve">
<value>Hard disk size, GB:</value>
</data>
<data name="locHoldCtrl.Text" xml:space="preserve">
<value>* Hold CTRL key to select multiple addresses</value>
</data>
<data name="locHostname.Text" xml:space="preserve">
<value>Host name:</value>
</data>
<data name="locMB.Text" xml:space="preserve">
<value>MB</value>
</data>
<data name="locNameStepTitle.Text" xml:space="preserve">
<value>Name and Operating System</value>
</data>
<data name="locNumLock.Text" xml:space="preserve">
<value>"Num Lock" enabled:</value>
</data>
<data name="locOnePerLine.Text" xml:space="preserve">
<value>* Type one IP address per line</value>
</data>
<data name="locOperatingSystem.Text" xml:space="preserve">
<value>Operating system:</value>
</data>
<data name="locPauseResumeAllowed.Text" xml:space="preserve">
<value>Pause, resume allowed:</value>
</data>
<data name="locPrivateAddresses.Text" xml:space="preserve">
<value>Number of IP addresses:</value>
</data>
<data name="locPrivateAddressesList.Text" xml:space="preserve">
<value>IP addresses list:</value>
</data>
<data name="locPrivateAddressesNumber.Text" xml:space="preserve">
<value>Number of IP addresses:</value>
</data>
<data name="locPrivateNetwork.Text" xml:space="preserve">
<value>Private Network</value>
</data>
<data name="locPrivateNetworkEnabled.Text" xml:space="preserve">
<value>Private network enabled:</value>
</data>
<data name="locPrivateNetworkFormat.Text" xml:space="preserve">
<value>Network addresses format:</value>
</data>
<data name="locPrivateSubnetMask.Text" xml:space="preserve">
<value>Subnet mask:</value>
</data>
<data name="locRam.Text" xml:space="preserve">
<value>RAM, MB:</value>
</data>
<data name="locRebootAllowed.Text" xml:space="preserve">
<value>Reboot allowed:</value>
</data>
<data name="locReinstallAllowed.Text" xml:space="preserve">
<value>Re-install allowed:</value>
</data>
<data name="locResetAllowed.Text" xml:space="preserve">
<value>Reset allowed:</value>
</data>
<data name="locSnapshots.Text" xml:space="preserve">
<value>Number of snapshots:</value>
</data>
<data name="locStartShutdownAllowed.Text" xml:space="preserve">
<value>Start, turn off and shutdown allowed:</value>
</data>
<data name="locSummary.Text" xml:space="preserve">
<value>Summary</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Create New VPS</value>
</data>
<data name="radioExternalRandom.Text" xml:space="preserve">
<value>Randomly select IP addresses from the pool</value>
</data>
<data name="radioExternalSelected.Text" xml:space="preserve">
<value>Select IP addresses from the list</value>
</data>
<data name="radioPrivateRandom.Text" xml:space="preserve">
<value>Randomly select next available IP addresses to the addresses format</value>
</data>
<data name="radioPrivateSelected.Text" xml:space="preserve">
<value>Assign specified IP addresses</value>
</data>
<data name="secActions.Text" xml:space="preserve">
<value>Allowed actions</value>
</data>
<data name="secBios.Text" xml:space="preserve">
<value>BIOS</value>
</data>
<data name="secDvd.Text" xml:space="preserve">
<value>DVD</value>
</data>
<data name="secResources.Text" xml:space="preserve">
<value>Resources</value>
</data>
<data name="secSnapshots.Text" xml:space="preserve">
<value>Snapshots</value>
</data>
<data name="OperatingSystemValidator.ErrorMessage" xml:space="preserve">
<value>Select operating system template</value>
</data>
<data name="SelectOsTemplate.Text" xml:space="preserve">
<value>&lt;Select OS template&gt;</value>
</data>
<data name="btnFinish.OnClientClick" xml:space="preserve">
<value>ShowProgressDialog('Creating Virtual Server...');</value>
</data>
<data name="litMaxExternalAddresses.Text" xml:space="preserve">
<value>({0} max)</value>
</data>
<data name="litMaxPrivateAddresses.Text" xml:space="preserve">
<value>({0} max)</value>
</data>
<data name="locNotEnoughExternalAddresses.Text" xml:space="preserve">
<value>The pool of available external IP addresses is empty. All IP addresses allocated to the current hosting space are assigned to existing virtual servers. More external IP addresses could be allocated by the host.</value>
</data>
<data name="valCorrectHostname.ErrorMessage" xml:space="preserve">
<value>Enter correct host name, for example "vps01"</value>
</data>
<data name="valNewDomainFormat.ErrorMessage" xml:space="preserve">
<value>Enter correct domain name, for example "mydomain.com"</value>
</data>
<data name="locGeneration.Text" xml:space="preserve">
<value>Generation:</value>
</data>
<data name="locDynamicMemory.Text" xml:space="preserve">
<value>Dynamic Memory</value>
</data>
</root>

135
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VdcExternalNetwork.ascx.resx Normal file
View file

@ -0,0 +1,135 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;The form displays the list of IP addresses from "VPS External Network" pool allocated to the hosting space. Alternatively, this form could be considered as a "map" of external IP addresses and their assignments to virtual machines.&lt;/p&gt;&lt;p&gt;If any IP has already assigned to some VPS then there will be VPS host name in the "Item name" column.&lt;/p&gt;&lt;p&gt;If there are lot of VPS in the hosting space you can easily search them by their external IP.&lt;/p&gt;&lt;p&gt;"Number of IP addresses" quota shows the maximum number of external IP addresses that could be allocated to this space.&lt;/p&gt;</value>
</data>
<data name="locBandwidthQuota.Text" xml:space="preserve">
<value>Bandwidth, GB:</value>
</data>
<data name="locIPQuota.Text" xml:space="preserve">
<value>Number of IP Addresses:</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>External Network</value>
</data>
<data name="secQuotas.Text" xml:space="preserve">
<value>Quotas</value>
</data>
</root>

189
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VdcHome.ascx.resx Normal file
View file

@ -0,0 +1,189 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnCreate.Text" xml:space="preserve">
<value>Create VM</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;The form displays the list of Virtual Private Servers created in the hosting space.&lt;/p&gt;&lt;p&gt;In terms of WebsitePanel VPS module hosting space could be compared to the Virtual Dedicated Center (VDC). You can see VPS bindings to external and private IP addresses as well as search VPS by these fields.&lt;/p&gt;&lt;p&gt;Quotas in the bottom of the forms show the total amount of computer resources available for VPS.&lt;/p&gt;</value>
</data>
<data name="gvServers.Empty" xml:space="preserve">
<value>No VPS have been created. To create a new VPS click "Create VPS" button.</value>
</data>
<data name="gvServersExternalIP.HeaderText" xml:space="preserve">
<value>External IP</value>
</data>
<data name="gvServersName.HeaderText" xml:space="preserve">
<value>Host name</value>
</data>
<data name="gvServersPrivateIP.HeaderText" xml:space="preserve">
<value>Private IP</value>
</data>
<data name="gvServersSpace.HeaderText" xml:space="preserve">
<value>Space</value>
</data>
<data name="gvServersUser.HeaderText" xml:space="preserve">
<value>User</value>
</data>
<data name="SearchField.ExternalIP" xml:space="preserve">
<value>External IP</value>
</data>
<data name="SearchField.IPAddress" xml:space="preserve">
<value>Private IP</value>
</data>
<data name="SearchField.ItemName" xml:space="preserve">
<value>VPS Name</value>
</data>
<data name="SearchField.Username" xml:space="preserve">
<value>User Name</value>
</data>
<data name="cmdDelete.Text" xml:space="preserve">
<value>Delete</value>
</data>
<data name="locHddQuota.Text" xml:space="preserve">
<value>HDD, GB:</value>
</data>
<data name="locRamQuota.Text" xml:space="preserve">
<value>RAM, MB:</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Virtual Private Servers</value>
</data>
<data name="locVpsQuota.Text" xml:space="preserve">
<value>Number of VPS:</value>
</data>
<data name="secQuotas.Text" xml:space="preserve">
<value>Quotas</value>
</data>
<data name="btnImport.Text" xml:space="preserve">
<value>Import VPS</value>
</data>
<data name="cmdDetach.OnClientClick" xml:space="preserve">
<value>return confirm('Remove this VM from meta-base?');</value>
</data>
<data name="cmdDetach.Text" xml:space="preserve">
<value>Detach</value>
</data>
<data name="cmdMove.Text" xml:space="preserve">
<value>Move</value>
</data>
<data name="btnFastCreate.Text" xml:space="preserve">
<value>Fast Create VM</value>
</data>
</root>

243
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VdcImportServer.ascx.resx Normal file
View file

@ -0,0 +1,243 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="AllowPause.Text" xml:space="preserve">
<value>Pause, Resume</value>
</data>
<data name="AllowReboot.Text" xml:space="preserve">
<value>Reboot</value>
</data>
<data name="AllowReset.Text" xml:space="preserve">
<value>Reset</value>
</data>
<data name="AllowStartShutdown.Text" xml:space="preserve">
<value>Start, Turn off and Shutdown</value>
</data>
<data name="btnCancel.Text" xml:space="preserve">
<value>Cancel</value>
</data>
<data name="btnImport.Text" xml:space="preserve">
<value>Import</value>
</data>
<data name="EnableRemoteDesktop.Text" xml:space="preserve">
<value>Enable Remote Desktop Web Connection</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;This wizard allows you to import existing Virtual Machine to control panel meta-base to provide its owner self-service functions.&lt;/p&gt;&lt;p&gt;Importing is absolutely safe for VM as nor VM configuration, nor its state are changing during the process.&lt;/p&gt;&lt;p&gt;To import VM, first, select registered in control panel Hyper-V service where VM is located. Then select VM, specify its allowed actions and select network adapter bindings.&lt;/p&gt;&lt;p&gt;External and management networks are determined on appropriate Hyper-V service properties page.&lt;/p&gt;&lt;p&gt;To enable Remote Desktop Web connections you have to provide real guest OS administrator password (for automatic sign-on).&lt;/p&gt;</value>
</data>
<data name="locAdminPassword.Text" xml:space="preserve">
<value>Administrator password:</value>
</data>
<data name="locBootFromCd.Text" xml:space="preserve">
<value>Boot from CD</value>
</data>
<data name="locCPU.Text" xml:space="preserve">
<value>CPU, cores:</value>
</data>
<data name="locDvdInstalled.Text" xml:space="preserve">
<value>DVD drive is installed</value>
</data>
<data name="locExternalAdapter.Text" xml:space="preserve">
<value>Connected NIC:</value>
</data>
<data name="locExternalAddresses.Text" xml:space="preserve">
<value>Assign IP addresses:</value>
</data>
<data name="locHDD.Text" xml:space="preserve">
<value>HDD, Gb:</value>
</data>
<data name="locHyperVService.Text" xml:space="preserve">
<value>Hyper-V Service:</value>
</data>
<data name="locManagementAdapter.Text" xml:space="preserve">
<value>Connected NIC:</value>
</data>
<data name="locManagementAddresses.Text" xml:space="preserve">
<value>Assign IP addresses:</value>
</data>
<data name="locNumLockEnabled.Text" xml:space="preserve">
<value>Num Lock</value>
</data>
<data name="locRAM.Text" xml:space="preserve">
<value>RAM, Mb:</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Import Existing VPS</value>
</data>
<data name="locVhdPath.Text" xml:space="preserve">
<value>VHD location:</value>
</data>
<data name="locVirtualMachine.Text" xml:space="preserve">
<value>Virtual Machine:</value>
</data>
<data name="secAllowedActions.Text" xml:space="preserve">
<value>Allowed Actions</value>
</data>
<data name="secBios.Text" xml:space="preserve">
<value>BIOS</value>
</data>
<data name="secConfiguration.Text" xml:space="preserve">
<value>Configuration</value>
</data>
<data name="secDvd.Text" xml:space="preserve">
<value>DVD</value>
</data>
<data name="secExternalNetwork.Text" xml:space="preserve">
<value>External Network</value>
</data>
<data name="secManagementNetwork.Text" xml:space="preserve">
<value>Management Network</value>
</data>
<data name="secOsTemplate.Text" xml:space="preserve">
<value>OS Template:</value>
</data>
<data name="SelectHyperVService.Text" xml:space="preserve">
<value>&lt;Select Hyper-V service&gt;</value>
</data>
<data name="SelectVirtualMachine.Text" xml:space="preserve">
<value>&lt;Select virtual machine&gt;</value>
</data>
<data name="RequiredOsTemplate.ErrorMessage" xml:space="preserve">
<value>Please select OS template</value>
</data>
<data name="RequiredVirtualMachine.ErrorMessage" xml:space="preserve">
<value>Please select virtual machine to import</value>
</data>
<data name="RequireHyperVService.ErrorMessage" xml:space="preserve">
<value>Please select Hyper-V service to import VPS from</value>
</data>
<data name="SelectOsTemplate.Text" xml:space="preserve">
<value>&lt;Select Operating System template&gt;</value>
</data>
<data name="btnImport.OnClientClick" xml:space="preserve">
<value>ShowProgressDialog('Importing Virtual Server...');</value>
</data>
<data name="RequiredAdminPassword.ErrorMessage" xml:space="preserve">
<value>Please enter guest OS administrator password</value>
</data>
<data name="RequiredExternalAddresses.ErrorMessage" xml:space="preserve">
<value>Select at least one External IP address</value>
</data>
<data name="RequiredManagementAddresses.ErrorMessage" xml:space="preserve">
<value>Select at least one Management IP address</value>
</data>
<data name="SelectNetworkAdapter.Text" xml:space="preserve">
<value>&lt;Not connected&gt;</value>
</data>
</root>

126
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VdcManagementNetwork.ascx.resx Normal file
View file

@ -0,0 +1,126 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;&lt;b&gt;This form is visible to administrators only.&lt;/b&gt;&lt;/p&gt;&lt;p&gt; Management network is not available to resellers and users and it's being managed by WebsitePanel on their behalf.&lt;/p&gt;&lt;p&gt;Management network is a back-end company network used by system administrators to manage customers' VPS. This network is also used by VPS to access various utility resources and services such as DNS, KMS, backups, etc.&lt;/p&gt;&lt;p&gt;If Management network is enabled on Hyper-V service properties then every created VPS will be assigned one IP address from "VPS Management Network" pool, so WebsitePanel administrator must make sure there are sufficient number of IP addresses in that pool.&lt;/p&gt;</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Management Network</value>
</data>
</root>

138
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VdcPermissions.ascx.resx Normal file
View file

@ -0,0 +1,138 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnUpdateVdcPermissions.OnClientClick" xml:space="preserve">
<value>ShowProgressDialog('Updating permissions...');</value>
</data>
<data name="btnUpdateVpsPermissions.OnClientClick" xml:space="preserve">
<value>ShowProgressDialog('Updating permissions...');</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>User permissions allow...</value>
</data>
<data name="gvVdcPermissions.Empty" xml:space="preserve">
<value>No peers exist under your user account.</value>
</data>
<data name="gvVpsPermissions.Empty" xml:space="preserve">
<value>No peers exist under your user account.</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>User Permissions</value>
</data>
</root>

150
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VdcPrivateNetwork.ascx.resx Normal file
View file

@ -0,0 +1,150 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;If this form is available in the hosting space then it means that all VPS in this hosting space are connected to dedicated private network available only to this hosting space.&lt;/p&gt; &lt;p&gt;Private network is a very powerful mechanizm that allows additional increase of network security. For example, you might have only one front-end server (e.g. server with Exchange CAS and HUB roles installed) connected to External network and all the rest of servers connected to private (internal) network only (e.g. one server with Exchange MB role and second one with DC).&lt;/p&gt;&lt;p&gt;Quota in the bottom of the form displays the maximum number of private IP addresses that could be assigned to every VPS.&lt;/p&gt;</value>
</data>
<data name="gvAddresses.Empty" xml:space="preserve">
<value>No private IP addresses have been used in this hosting space.</value>
</data>
<data name="SearchField.IPAddress" xml:space="preserve">
<value>IP Address</value>
</data>
<data name="SearchField.ItemName" xml:space="preserve">
<value>VPS Name</value>
</data>
<data name="gvAddressesIPAddress.HeaderText" xml:space="preserve">
<value>IP</value>
</data>
<data name="gvAddressesItemName.HeaderText" xml:space="preserve">
<value>VPS</value>
</data>
<data name="gvAddressesPrimary.HeaderText" xml:space="preserve">
<value>Primary</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Private Network</value>
</data>
<data name="locVpsAddressesQuota.Text" xml:space="preserve">
<value>IP addresses per VPS:</value>
</data>
<data name="secQuotas.Text" xml:space="preserve">
<value>Quotas</value>
</data>
</root>

156
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsDetailsAddExternalAddress.ascx.resx Normal file
View file

@ -0,0 +1,156 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnAdd.Text" xml:space="preserve">
<value>Add</value>
</data>
<data name="btnCancel.Text" xml:space="preserve">
<value>Cancel</value>
</data>
<data name="ExternalAddressesValidator.ErrorMessage" xml:space="preserve">
<value>Enter the number of IP addresses</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;This form allows assigning of new IP addresses to VPS "External" network adapter.&lt;/p&gt;&lt;p&gt;Additional IP addresses could be assigned to the VPS if only there is enough number of free (unassigned) external IP addresses allocated to this hosting space.&lt;/p&gt;&lt;p&gt;After clicking "Add" button special configuration instructions will be sent to VPS, so it may take some time (up to few minutes) until network adapter parameters are changed.&lt;/p&gt;</value>
</data>
<data name="locExternalAddresses.Text" xml:space="preserve">
<value>Number of IP addresses:</value>
</data>
<data name="locHoldCtrl.Text" xml:space="preserve">
<value>* Hold CTRL key to select multiple addresses</value>
</data>
<data name="locSubTitle.Text" xml:space="preserve">
<value>Add External IP Addresses</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Network</value>
</data>
<data name="radioExternalRandom.Text" xml:space="preserve">
<value>Randomly select IP addresses from the pool</value>
</data>
<data name="radioExternalSelected.Text" xml:space="preserve">
<value>Select IP addresses from the list</value>
</data>
<data name="litMaxExternalAddresses.Text" xml:space="preserve">
<value>({0} max)</value>
</data>
<data name="locNotEnoughExternalAddresses.Text" xml:space="preserve">
<value>The pool of available external IP addresses is empty. All IP addresses allocated to the current hosting space are assigned to existing virtual servers. More external IP addresses could be allocated by the host.</value>
</data>
</root>

153
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsDetailsAddPrivateAddress.ascx.resx Normal file
View file

@ -0,0 +1,153 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnAdd.Text" xml:space="preserve">
<value>Add</value>
</data>
<data name="btnCancel.Text" xml:space="preserve">
<value>Cancel</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;This form allows assigning of new IP addresses to VPS "Private" network adapter.&lt;/p&gt;&lt;p&gt;In the private network you could assign any IP addresses to VPS, however if you decide to leave this job for WebsitePanel then it will generate private IP addresses for you by the algorithm set on the service level and make sure IPs are not duplicated.&lt;/p&gt;&lt;p&gt;After clicking "Add" button special configuration instructions will be sent to VPS, so it may take some time (up to few minutes) until network adapter parameters are changed.&lt;/p&gt;</value>
</data>
<data name="locOnePerLine.Text" xml:space="preserve">
<value>* Type one IP address per line</value>
</data>
<data name="locPrivateAddresses.Text" xml:space="preserve">
<value>Number of IP addresses:</value>
</data>
<data name="locSubTitle.Text" xml:space="preserve">
<value>Add Private IP Addresses</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Network</value>
</data>
<data name="PrivateAddressesValidator.ErrorMessage" xml:space="preserve">
<value>Enter the number of private IP addresses</value>
</data>
<data name="radioPrivateRandom.Text" xml:space="preserve">
<value>Randomly select next available IP addresses to the addresses format</value>
</data>
<data name="radioPrivateSelected.Text" xml:space="preserve">
<value>Assign specified IP addresses</value>
</data>
<data name="litMaxPrivateAddresses.Text" xml:space="preserve">
<value>({0} max)</value>
</data>
</root>

126
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsDetailsAuditLog.ascx.resx Normal file
View file

@ -0,0 +1,126 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;Audit log displays the chronology of events for this VPS.&lt;/p&gt;&lt;p&gt;By default audit log displays all today's events. You may filter the log by date (day, week, month), severity, task and item name (VPS host name).&lt;/p&gt;&lt;p&gt;To see task details click the link with task name in "Task" column.&lt;/p&gt;&lt;p&gt;To export log in CSV format click "Export Log" button.&lt;/p&gt;</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Audit Log</value>
</data>
</root>

222
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsDetailsConfiguration.ascx.resx Normal file
View file

@ -0,0 +1,222 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnChangePassword.OnClientClick" xml:space="preserve">
<value>ShowProgressDialog('Changing password...', 'PasswordModal');</value>
</data>
<data name="CpuCores.Text" xml:space="preserve">
<value>{0} cores</value>
</data>
<data name="Hdd.Text" xml:space="preserve">
<value>{0} GB</value>
</data>
<data name="Ram.Text" xml:space="preserve">
<value>{0} MB</value>
</data>
<data name="secNetwork.Text" xml:space="preserve">
<value>Network</value>
</data>
<data name="btnCancelChangePassword.Text" xml:space="preserve">
<value>Cancel</value>
</data>
<data name="btnChangePassword.Text" xml:space="preserve">
<value>Change password</value>
</data>
<data name="btnChangePasswordPopup.Text" xml:space="preserve">
<value>Change</value>
</data>
<data name="btnEdit.Text" xml:space="preserve">
<value>Edit configuration</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;This form shows VPS configuration.&lt;/p&gt;&lt;p&gt;To change VPS Administrator account password click "Change" link in "Software" section.&lt;br/&gt;To change password special configuration instructions will be sent to VPS, so it may take some time (up to few minutes) until it is changed.&lt;/p&gt;&lt;p&gt;To change VPS configuration (if allowed in the hosting plan) click "Edit configuration" button.&lt;/p&gt;</value>
</data>
<data name="lblCpu.Text" xml:space="preserve">
<value>CPU:</value>
</data>
<data name="lblHdd.Text" xml:space="preserve">
<value>HDD:</value>
</data>
<data name="lblRam.Text" xml:space="preserve">
<value>RAM:</value>
</data>
<data name="locAdministratorPassword.Text" xml:space="preserve">
<value>Administrator password:</value>
</data>
<data name="locChangePassword.Text" xml:space="preserve">
<value>Change Administrator Password</value>
</data>
<data name="locNewPassword.Text" xml:space="preserve">
<value>Enter new password:</value>
</data>
<data name="locOperatingSystem.Text" xml:space="preserve">
<value>Operating system:</value>
</data>
<data name="locSnapshots.Text" xml:space="preserve">
<value>Number of snapshots:</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Configuration</value>
</data>
<data name="optionBootFromCd.Text" xml:space="preserve">
<value>Boot from CD</value>
</data>
<data name="optionDvdInstalled.Text" xml:space="preserve">
<value>DVD drive installed</value>
</data>
<data name="optionExternalNetwork.Text" xml:space="preserve">
<value>External network enabled</value>
</data>
<data name="optionNumLock.Text" xml:space="preserve">
<value>Num Lock enabled</value>
</data>
<data name="optionPauseResume.Text" xml:space="preserve">
<value>Pause, Resume</value>
</data>
<data name="optionPrivateNetwork.Text" xml:space="preserve">
<value>Private network enabled</value>
</data>
<data name="optionReboot.Text" xml:space="preserve">
<value>Reboot</value>
</data>
<data name="optionReinstall.Text" xml:space="preserve">
<value>Re-Install</value>
</data>
<data name="optionReset.Text" xml:space="preserve">
<value>Reset</value>
</data>
<data name="optionStartShutdown.Text" xml:space="preserve">
<value>Start, Turn off and Shutdown</value>
</data>
<data name="secActions.Text" xml:space="preserve">
<value>Server Actions</value>
</data>
<data name="secBios.Text" xml:space="preserve">
<value>BIOS</value>
</data>
<data name="secDvd.Text" xml:space="preserve">
<value>DVD</value>
</data>
<data name="secResources.Text" xml:space="preserve">
<value>Resources</value>
</data>
<data name="secSnapshots.Text" xml:space="preserve">
<value>Snapshots</value>
</data>
</root>

141
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsDetailsDvd.ascx.resx Normal file
View file

@ -0,0 +1,141 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnEjectDisk.OnClientClick" xml:space="preserve">
<value>ShowProgressDialog('Ejecting disk...');</value>
</data>
<data name="NoDisk.Text" xml:space="preserve">
<value>&lt;empty&gt;</value>
</data>
<data name="btnEjectDisk.Text" xml:space="preserve">
<value>Eject</value>
</data>
<data name="btnInsertDisk.Text" xml:space="preserve">
<value>Insert Disk...</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;The form shows the status of DVD drive. If there is &lt;b&gt;&amp;lt;empty&amp;gt;&lt;/b&gt; then there is no disk in the drive.&lt;/p&gt;&lt;p&gt;Click &lt;b&gt;"Insert Disk..."&lt;/b&gt; button to browse Media Library.&lt;/p&gt;&lt;p&gt;Click &lt;b&gt;"Eject"&lt;/b&gt; button to remove disk from DVD drive.&lt;/p&gt;</value>
</data>
<data name="locDvdDrive.Text" xml:space="preserve">
<value>DVD Drive:</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>DVD</value>
</data>
</root>

216
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsDetailsEditConfiguration.ascx.resx Normal file
View file

@ -0,0 +1,216 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnCancel.Text" xml:space="preserve">
<value>Cancel</value>
</data>
<data name="btnUpdate.OnClientClick" xml:space="preserve">
<value>if(!confirm('Before applying new configuration VPS will be stopped.\n\nAfter the configuration is changed it will be started again automatically.\n\nDo you want to proceed?')) return false; ShowProgressDialog('Updating configuration...');</value>
</data>
<data name="btnUpdate.Text" xml:space="preserve">
<value>Update</value>
</data>
<data name="chkBootFromCd.Text" xml:space="preserve">
<value>Boot from CD</value>
</data>
<data name="chkDvdInstalled.Text" xml:space="preserve">
<value>DVD drive installed</value>
</data>
<data name="chkExternalNetworkEnabled.Text" xml:space="preserve">
<value>External network enabled</value>
</data>
<data name="chkNumLock.Text" xml:space="preserve">
<value>Num Lock enabled</value>
</data>
<data name="chkPauseResume.Text" xml:space="preserve">
<value>Pause, Resume</value>
</data>
<data name="chkPrivateNetworkEnabled.Text" xml:space="preserve">
<value>Private network enabled</value>
</data>
<data name="chkReboot.Text" xml:space="preserve">
<value>Reboot</value>
</data>
<data name="chkReinstall.Text" xml:space="preserve">
<value>Re-Install</value>
</data>
<data name="chkReset.Text" xml:space="preserve">
<value>Reset</value>
</data>
<data name="chkStartShutdown.Text" xml:space="preserve">
<value>Start, Turn off and Shutdown</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;Change VPS configuration and click "Update" button.&lt;/p&gt;&lt;p&gt;&lt;b&gt;Before applying new configuration settings VPS will be stopped. After new configuration is applied it will be started again.&lt;/b&gt;&lt;/p&gt;</value>
</data>
<data name="lblCpu.Text" xml:space="preserve">
<value>CPU:</value>
</data>
<data name="lblHdd.Text" xml:space="preserve">
<value>HDD:</value>
</data>
<data name="lblRam.Text" xml:space="preserve">
<value>RAM:</value>
</data>
<data name="locCores.Text" xml:space="preserve">
<value>cores</value>
</data>
<data name="locGB.Text" xml:space="preserve">
<value>GB</value>
</data>
<data name="locMB.Text" xml:space="preserve">
<value>MB</value>
</data>
<data name="locSnapshots.Text" xml:space="preserve">
<value>Number of snapshots:</value>
</data>
<data name="locSubTitle.Text" xml:space="preserve">
<value>Edit Configuration</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Edit Configuration</value>
</data>
<data name="RequireHddValidator.ErrorMessage" xml:space="preserve">
<value>Please specify HDD size</value>
</data>
<data name="RequireRamValidator.ErrorMessage" xml:space="preserve">
<value>Please specify RAM size</value>
</data>
<data name="secActions.Text" xml:space="preserve">
<value>Server Actions</value>
</data>
<data name="secBios.Text" xml:space="preserve">
<value>BIOS</value>
</data>
<data name="secDvd.Text" xml:space="preserve">
<value>DVD</value>
</data>
<data name="secNetwork.Text" xml:space="preserve">
<value>Network</value>
</data>
<data name="secResources.Text" xml:space="preserve">
<value>Resources</value>
</data>
<data name="secSnapshots.Text" xml:space="preserve">
<value>Snapshots</value>
</data>
<data name="SnapshotsValidator.ErrorMessage" xml:space="preserve">
<value>Please enter the number of snapshots</value>
</data>
</root>

303
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsDetailsGeneral.ascx.resx Normal file
View file

@ -0,0 +1,303 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnChangeHostname.OnClientClick" xml:space="preserve">
<value>ShowProgressDialog('Changing host name...', 'ChangeHostnameModal');</value>
</data>
<data name="btnDelete.Text" xml:space="preserve">
<value>Delete</value>
</data>
<data name="Command.Pause" xml:space="preserve">
<value>Pause</value>
</data>
<data name="Command.Reboot" xml:space="preserve">
<value>Reboot</value>
</data>
<data name="Command.Reset" xml:space="preserve">
<value>Reset</value>
</data>
<data name="Command.Resume" xml:space="preserve">
<value>Resume</value>
</data>
<data name="Command.ShutDown" xml:space="preserve">
<value>Shut&amp;nbsp;Down</value>
</data>
<data name="Command.Snapshot" xml:space="preserve">
<value>Snapshot</value>
</data>
<data name="Command.Start" xml:space="preserve">
<value>Start</value>
</data>
<data name="Command.TurnOff" xml:space="preserve">
<value>Turn&amp;nbsp;Off</value>
</data>
<data name="CpuPercentage.Text" xml:space="preserve">
<value>{0}%</value>
</data>
<data name="MemoryPercentage.Text" xml:space="preserve">
<value>{0}%</value>
</data>
<data name="MemoryUsage.Text" xml:space="preserve">
<value>Used: {0} MB, Total: {1} MB</value>
</data>
<data name="OnClientClick.Pause" xml:space="preserve">
<value>if(!confirm('Pause VPS?')) return false; ShowProgressDialog('Pausing...');</value>
</data>
<data name="OnClientClick.Reboot" xml:space="preserve">
<value>if(!confirm('Reboot VPS?')) return false; ShowProgressDialog('Rebooting...');</value>
</data>
<data name="OnClientClick.Reset" xml:space="preserve">
<value>if(!confirm('Reset VPS?')) return false; ShowProgressDialog('Resetting...');</value>
</data>
<data name="OnClientClick.Resume" xml:space="preserve">
<value>ShowProgressDialog('Resuming...');</value>
</data>
<data name="OnClientClick.ShutDown" xml:space="preserve">
<value>if(!confirm('Shut down VPS?')) return false; ShowProgressDialog('Shutting down...');</value>
</data>
<data name="OnClientClick.Snapshot" xml:space="preserve">
<value>ShowProgressDialog('Taking snapshot...');</value>
</data>
<data name="OnClientClick.Start" xml:space="preserve">
<value>ShowProgressDialog('Starting...');</value>
</data>
<data name="OnClientClick.TurnOff" xml:space="preserve">
<value>if(!confirm('Turn off VPS?')) return false; ShowProgressDialog('Turning off...');</value>
</data>
<data name="locHostname.Text" xml:space="preserve">
<value>Host&amp;nbsp;name:</value>
</data>
<data name="btnCancelHostname.Text" xml:space="preserve">
<value>Cancel</value>
</data>
<data name="btnChangeHostname.Text" xml:space="preserve">
<value>Change</value>
</data>
<data name="btnChangeHostnamePopup.Text" xml:space="preserve">
<value>Edit</value>
</data>
<data name="chkUpdateComputerName.Text" xml:space="preserve">
<value>Update computer network name</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;&lt;b&gt;Status&lt;/b&gt; shows the current state of VPS. The list of available VPS action buttons on the right depends on the current status.&lt;/p&gt;&lt;p&gt;&lt;b&gt;Uptime&lt;/b&gt; is the time since the last VPS start.&lt;/p&gt;&lt;b&gt;Heartbeat&lt;/b&gt; is a very useful indicator as it shows whether VPS operating system is active and respond. If there is "No contact" then it means the system is not started yet, but if there is an "Error" then it means OS does not respond to the host machine.&lt;/p&gt;&lt;p&gt;&lt;b&gt;CPU&lt;/b&gt; meter displays VPS processor utilization.&lt;/p&gt;&lt;p&gt;&lt;b&gt;RAM&lt;/b&gt; and &lt;b&gt;HDD&lt;/b&gt; meters show real-time data provided by VPS operating system.&lt;/p&gt;</value>
</data>
<data name="Heartbeat.Error" xml:space="preserve">
<value>Error</value>
</data>
<data name="Heartbeat.LostCommunication" xml:space="preserve">
<value>Lost communication</value>
</data>
<data name="Heartbeat.NoContact" xml:space="preserve">
<value>No contact</value>
</data>
<data name="Heartbeat.None" xml:space="preserve">
<value>None</value>
</data>
<data name="Heartbeat.OK" xml:space="preserve">
<value>OK</value>
</data>
<data name="Heartbeat.Paused" xml:space="preserve">
<value>Paused</value>
</data>
<data name="locChangeHostname.Text" xml:space="preserve">
<value>Change VPS Host Name</value>
</data>
<data name="locCpu.Text" xml:space="preserve">
<value>CPU:</value>
</data>
<data name="locCreated.Text" xml:space="preserve">
<value>Created:</value>
</data>
<data name="locDomain.Text" xml:space="preserve">
<value>Domain:</value>
</data>
<data name="locHeartbeat.Text" xml:space="preserve">
<value>Heartbeat:</value>
</data>
<data name="locHostname1.Text" xml:space="preserve">
<value>Host name:</value>
</data>
<data name="locRam.Text" xml:space="preserve">
<value>RAM:</value>
</data>
<data name="locStatus.Text" xml:space="preserve">
<value>Status:</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>General</value>
</data>
<data name="locUptime.Text" xml:space="preserve">
<value>Uptime:</value>
</data>
<data name="State.Deleted" xml:space="preserve">
<value>Deleted</value>
</data>
<data name="State.Migrating" xml:space="preserve">
<value>Migrating</value>
</data>
<data name="State.Off" xml:space="preserve">
<value>Off</value>
</data>
<data name="State.Paused" xml:space="preserve">
<value>Paused</value>
</data>
<data name="State.Pausing" xml:space="preserve">
<value>Pausing</value>
</data>
<data name="State.Saved" xml:space="preserve">
<value>Saved</value>
</data>
<data name="State.Saving" xml:space="preserve">
<value>Saving</value>
</data>
<data name="State.Snapshotting" xml:space="preserve">
<value>Taking Snapshot</value>
</data>
<data name="State.Started" xml:space="preserve">
<value>Running</value>
</data>
<data name="State.Starting" xml:space="preserve">
<value>Starting</value>
</data>
<data name="State.Running" xml:space="preserve">
<value>Running</value>
</data>
<data name="State.Stopping" xml:space="preserve">
<value>Stopping</value>
</data>
<data name="valCorrectHostname.ErrorMessage" xml:space="preserve">
<value>Enter correct host name, for example "vps01"</value>
</data>
<data name="valNewDomainFormat.ErrorMessage" xml:space="preserve">
<value>Enter correct domain name, for example "mydomain.com"</value>
</data>
<data name="HddPercentage.Text" xml:space="preserve">
<value>{0}%</value>
</data>
<data name="HddUsage.Text" xml:space="preserve">
<value>Free: {0} GB, Total: {1} GB on {2} drive(s)</value>
</data>
<data name="locHdd.Text" xml:space="preserve">
<value>HDD:</value>
</data>
<data name="locDomainTop.Text" xml:space="preserve">
<value>Domain:</value>
</data>
</root>

144
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsDetailsHelp.ascx.resx Normal file
View file

@ -0,0 +1,144 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnSend.OnClientClick" xml:space="preserve">
<value>ShowProgressDialog('Sending e-mail...');</value>
</data>
<data name="btnSend.Text" xml:space="preserve">
<value>Send</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;This form displays VPS summary information prepared by the host.&lt;/p&gt;&lt;p&gt;This information could be re-send to any e-mail address specified in "Send instructions by e-mail" section. This section is collapsed by default.&lt;/p&gt;</value>
</data>
<data name="lblBCC.Text" xml:space="preserve">
<value>BCC:</value>
</data>
<data name="lblTo.Text" xml:space="preserve">
<value>To:</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Help</value>
</data>
<data name="secEmail.Text" xml:space="preserve">
<value>Send instructions by e-mail</value>
</data>
<data name="valRequireEmail.ErrorMessage" xml:space="preserve">
<value>Please enter e-mail address</value>
</data>
</root>

144
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsDetailsInsertDvd.ascx.resx Normal file
View file

@ -0,0 +1,144 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnCancel.Text" xml:space="preserve">
<value>Cancel</value>
</data>
<data name="btnInsert.OnClientClick" xml:space="preserve">
<value>ShowProgressDialog('Inserting disk...');</value>
</data>
<data name="btnInsert.Text" xml:space="preserve">
<value>Insert</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;Browse Media Library and click &lt;b&gt;"Insert"&lt;/b&gt; button in the row with DVD you want to insert into drive.&lt;/p&gt;&lt;p&gt;Click &lt;b&gt;"Cancel"&lt;/b&gt; button to return to DVD drive properties screen.&lt;/p&gt;</value>
</data>
<data name="gvDisks.Empty" xml:space="preserve">
<value>No disks found in the media library.</value>
</data>
<data name="gvTitle.HeaderText" xml:space="preserve">
<value>Title</value>
</data>
<data name="locSubTitle.Text" xml:space="preserve">
<value>Browse Media Library</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>DVD</value>
</data>
</root>

195
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsDetailsNetwork.ascx.resx Normal file
View file

@ -0,0 +1,195 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnAddExternalAddress.Text" xml:space="preserve">
<value>Add IP...</value>
</data>
<data name="btnAddPrivateAddress.Text" xml:space="preserve">
<value>Add IP...</value>
</data>
<data name="btnDeleteExternal.Text" xml:space="preserve">
<value>Delete</value>
</data>
<data name="btnDeletePrivate.Text" xml:space="preserve">
<value>Delete</value>
</data>
<data name="btnSetPrimaryExternal.Text" xml:space="preserve">
<value>Set As Primary</value>
</data>
<data name="btnSetPrimaryPrivate.Text" xml:space="preserve">
<value>Set As Primary</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;This form shows VPS network configuration.&lt;/p&gt;&lt;p&gt;To assign additional IP addresses to "External" or "Private" adapter click "Add" button in the appropriate section.&lt;/p&gt;&lt;p&gt;When you delete external or private IP or change network adapter primary IP address the system sends special configuration instructions to VPS operating system, so it may take some time (up to few minutes) until network adapter parameters are changed.&lt;/p&gt;</value>
</data>
<data name="gvExternalAddresses.Empty" xml:space="preserve">
<value>No IP addresses are assigned to external network adapter.</value>
</data>
<data name="gvIpAddress.HeaderText" xml:space="preserve">
<value>IP Address</value>
</data>
<data name="gvPrimary.HeaderText" xml:space="preserve">
<value>Primary</value>
</data>
<data name="gvPrivateAddresses.Empty" xml:space="preserve">
<value>No IP addresses are assigned to private network adapter.</value>
</data>
<data name="locExtAddress.Text" xml:space="preserve">
<value>Server address:</value>
</data>
<data name="locExtGateway.Text" xml:space="preserve">
<value>Default gateway:</value>
</data>
<data name="locExtSubnet.Text" xml:space="preserve">
<value>Subnet mask:</value>
</data>
<data name="locPrivAddress.Text" xml:space="preserve">
<value>Server address:</value>
</data>
<data name="locPrivFormat.Text" xml:space="preserve">
<value>Network format:</value>
</data>
<data name="locPrivSubnet.Text" xml:space="preserve">
<value>Subnet mask:</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Network</value>
</data>
<data name="locTotalExternal.Text" xml:space="preserve">
<value>IP addresses:</value>
</data>
<data name="locTotalPrivate.Text" xml:space="preserve">
<value>IP addresses:</value>
</data>
<data name="secExternalNetwork.Text" xml:space="preserve">
<value>External Network</value>
</data>
<data name="secPrivateNetwork.Text" xml:space="preserve">
<value>Private Network</value>
</data>
<data name="Automatic.Text" xml:space="preserve">
<value>&amp;lt;auto&amp;gt;</value>
</data>
<data name="gvDefaultGateway.HeaderText" xml:space="preserve">
<value>Gateway</value>
</data>
<data name="gvSubnetMask.HeaderText" xml:space="preserve">
<value>Subnet Mask</value>
</data>
</root>

132
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsDetailsPermissions.ascx.resx Normal file
View file

@ -0,0 +1,132 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnUpdateVpsPermissions.OnClientClick" xml:space="preserve">
<value>ShowProgressDialog('Updating permissions...');</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>User permissions allow...</value>
</data>
<data name="gvVpsPermissions.Empty" xml:space="preserve">
<value>No peers exist under your user account.</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Permissions</value>
</data>
</root>

174
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsDetailsSnapshots.ascx.resx Normal file
View file

@ -0,0 +1,174 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnApply.OnClientClick" xml:space="preserve">
<value>if(this.disabled) return false;if(!confirm('Do you want to apply selected snapshot to VPS?')) return false;ShowProgressDialog('Applying snapshot...');</value>
</data>
<data name="btnDelete.OnClientClick" xml:space="preserve">
<value>if(this.disabled) return false;if(!confirm('Do you want to completely delete selected snapshot?')) return false;ShowProgressDialog('Deleting snapshot...');</value>
</data>
<data name="btnDeleteSubtree.OnClientClick" xml:space="preserve">
<value>if(!confirm('Do you want to completely delete selected snapshot and all its sub-tree?')) return false;ShowProgressDialog('Deleting snapshot sub-tree...');</value>
</data>
<data name="btnRenameSnapshot.OnClientClick" xml:space="preserve">
<value>ShowProgressDialog('Renaming snapshot...', 'RenameSnapshotModal');</value>
</data>
<data name="btnTakeSnapshot.OnClientClick" xml:space="preserve">
<value>ShowProgressDialog('Taking snapshot...');</value>
</data>
<data name="Now.Text" xml:space="preserve">
<value>Now</value>
</data>
<data name="locNoSnapshots.Text" xml:space="preserve">
<value>This virtual server has no snapshots.</value>
</data>
<data name="btnApply.Text" xml:space="preserve">
<value>Apply</value>
</data>
<data name="btnCancelRename.Text" xml:space="preserve">
<value>Cancel</value>
</data>
<data name="btnDelete.Text" xml:space="preserve">
<value>Delete</value>
</data>
<data name="btnDeleteSubtree.Text" xml:space="preserve">
<value>Delete Subtree</value>
</data>
<data name="btnRename.Text" xml:space="preserve">
<value>Rename</value>
</data>
<data name="btnRenameSnapshot.Text" xml:space="preserve">
<value>Rename</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;To take a &lt;b&gt;snapshot&lt;/b&gt; is much like to take a picture of current VPS state: its configuration, memory and hard disk.&lt;/p&gt;&lt;p&gt;Snapshots maybe used as backup/restore points when installing new software or using VPS for development or testing purposes. If something has gone wrong there is an ability to roll-back and &lt;b&gt;"Apply"&lt;/b&gt; a snapshot with good configuration.&lt;/p&gt;&lt;p&gt;&lt;b&gt;"Rename"&lt;/b&gt; button allows renaming snapshot and giving it some informative name, for example "Before applying service pack".&lt;/p&gt;</value>
</data>
<data name="locCreated.Text" xml:space="preserve">
<value>Created:</value>
</data>
<data name="locQuota.Text" xml:space="preserve">
<value>Number of Snapshots:</value>
</data>
<data name="locRenameSnapshot.Text" xml:space="preserve">
<value>Rename Snapshot</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Snapshots</value>
</data>
</root>

138
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsDetailsTools.ascx.resx Normal file
View file

@ -0,0 +1,138 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnDelete.Text" xml:space="preserve">
<value>Delete VPS</value>
</data>
<data name="btnReinstall.Text" xml:space="preserve">
<value>Re-install VPS</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value />
</data>
<data name="locDelete.Text" xml:space="preserve">
<value>Completely removes VPS and all its data.</value>
</data>
<data name="locReinstall.Text" xml:space="preserve">
<value>Re-creates VPS with the same configuration settings and operating system template. The wizard allows to preserve existing virtual disk data.</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Tools</value>
</data>
</root>

147
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsMoveServer.ascx.resx Normal file
View file

@ -0,0 +1,147 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnCancel.Text" xml:space="preserve">
<value>Cancel</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;This wizard allows you to change Hyper-V service binding for existing Virtual Machine meta-item.&lt;/p&gt;&lt;p&gt;The wizard &lt;b&gt;DOES NOT PERFORM&lt;/b&gt; physical virtual machine migration, but it could be used to point control panel to the right Hyper-V service AFTER virtual machine was moved with some external management tool like Hyper-V manager or SCVMM.&lt;/p&gt;</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Move VPS</value>
</data>
<data name="btnMove.OnClientClick" xml:space="preserve">
<value>ShowProgressDialog('Moving Virtual Server...');</value>
</data>
<data name="btnMove.Text" xml:space="preserve">
<value>Move</value>
</data>
<data name="locDestinationService.Text" xml:space="preserve">
<value>Destination Hyper-V Service:</value>
</data>
<data name="RequiredHyperVService.ErrorMessage" xml:space="preserve">
<value>Please select Hyper-V where VPS has been moved</value>
</data>
<data name="locSourceService.Text" xml:space="preserve">
<value>Source Hyper-V service:</value>
</data>
<data name="SelectHyperVService.Text" xml:space="preserve">
<value>&lt;Select Hyper-V service&gt;</value>
</data>
</root>

156
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsToolsDeleteServer.ascx.resx Normal file
View file

@ -0,0 +1,156 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnCancel.Text" xml:space="preserve">
<value>Cancel</value>
</data>
<data name="btnDelete.OnClientClick" xml:space="preserve">
<value>ShowProgressDialog('Deleting Virtual Server...');</value>
</data>
<data name="btnDelete.Text" xml:space="preserve">
<value>Delete</value>
</data>
<data name="chkConfirmDelete.Text" xml:space="preserve">
<value>Delete this Virtual Server</value>
</data>
<data name="chkExport.Text" xml:space="preserve">
<value>Export VPS before deletion to the following folder:</value>
</data>
<data name="chkSaveFiles.Text" xml:space="preserve">
<value>Do not delete VPS files (virtual hard disk, snapshots)</value>
</data>
<data name="ExportPathValidator.ErrorMessage" xml:space="preserve">
<value>Please enter export path</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value>&lt;p&gt;This form confirms deletion of VPS.&lt;/p&gt;&lt;p&gt;In order to confirm "Delete this virtual server" checkbox must be checked.&lt;/p&gt;</value>
</data>
<data name="locAdminOptions.Text" xml:space="preserve">
<value>Administrator options</value>
</data>
<data name="locDescription.Text" xml:space="preserve">
<value>This wizard will delete VPS and all its contents from the virtualization server.</value>
</data>
<data name="locSubTitle.Text" xml:space="preserve">
<value>Delete VPS Server</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Delete Server</value>
</data>
</root>

159
WebsitePanel/Sources/WebsitePanel.WebPortal/DesktopModules/WebsitePanel/VPS2012/App_LocalResources/VpsToolsReinstallServer.ascx.resx Normal file
View file

@ -0,0 +1,159 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="btnCancel.Text" xml:space="preserve">
<value>Cancel</value>
</data>
<data name="btnReinstall.Text" xml:space="preserve">
<value>Re-install</value>
</data>
<data name="chkConfirmReinstall.Text" xml:space="preserve">
<value>Yes, I confirm re-installation of this VPS</value>
</data>
<data name="chkExport.Text" xml:space="preserve">
<value>Export VPS before re-installation to the following folder:</value>
</data>
<data name="chkPreserveExistingFiles.Text" xml:space="preserve">
<value>Save existing VPS hard drive files</value>
</data>
<data name="chkSaveVhd.Text" xml:space="preserve">
<value>Do not delete VPS virtual hard drive file</value>
</data>
<data name="ExportPathValidator.ErrorMessage" xml:space="preserve">
<value>Enter export path</value>
</data>
<data name="FormComments.Text" xml:space="preserve">
<value />
</data>
<data name="locDescription.Text" xml:space="preserve">
<value>This wizard will re-create VPS with the same configuration settings from scratch and then apply current OS template.</value>
</data>
<data name="locPassword.Text" xml:space="preserve">
<value>New administrator password:</value>
</data>
<data name="locPreserveHelp.Text" xml:space="preserve">
<value>All files from existing hard drive will be copied to &amp;quot;old&amp;quot; disk folder on hard drive of new VPS.</value>
</data>
<data name="locSubTitle.Text" xml:space="preserve">
<value>Re-install VPS Server</value>
</data>
<data name="locTitle.Text" xml:space="preserve">
<value>Re-install Server</value>
</data>
</root>

Some files were not shown because too many files have changed in this diff Show more