public bool Run()
{
UUID sessionId = UUID.Random;
m_Log.Info("Create User");
try
{
var account = new UserAccount
{
Principal = m_UserID,
};
m_UserAccountService.Add(account);
}
catch (Exception e)
{
m_Log.Error("UserAccount failed", e);
return(false);
}
m_Log.Info("Create UserSession");
try
{
m_UserSessionService.CreateSession(m_UserID, m_ClientIPAddress, m_SessionID, m_SecureSessionID);
}
catch (Exception e)
{
m_Log.Error("UserSession failed", e);
return(false);
}
return(true);
}
private void CreateUserCommand(List <string> args, Common.CmdIO.TTY io, UUID limitedToScene)
{
if (args[0] == "help" || args.Count != 4)
{
io.Write("create user <firstname> <lastname>");
}
else if (limitedToScene != UUID.Zero)
{
io.Write("create user not allowed on limited console");
}
else if (!IsNameValid(args[1]) || !IsNameValid(args[2]))
{
io.Write("name can only contains letters or digits");
}
else if (m_UserAccountService.ContainsKey(args[1], args[2]))
{
io.Write("user already created");
}
else
{
var account = new UserAccount
{
IsLocalToGrid = true
};
account.Principal.ID = UUID.Random;
account.Principal.FirstName = args[2];
account.Principal.LastName = args[3];
account.UserLevel = 0;
var authInfo = new UserAuthInfo
{
ID = account.Principal.ID,
Password = io.GetPass("Password")
};
try
{
m_UserAccountService.Add(account);
}
catch
{
io.WriteFormatted("Could not add user account");
}
try
{
m_AuthInfoService.Store(authInfo);
}
catch
{
m_UserAccountService.Remove(account.Principal.ID);
io.WriteFormatted("Could not add user account");
}
}
}
public bool Run()
{
m_Log.Info("Setting up test data");
UUID userID = UUID.Parse("22334455-1122-1122-1122-112233445566");
var ua = new UserAccount
{
Principal = new UGUIWithName {
ID = userID, FirstName = "First", LastName = "Last"
},
Email = "*****@*****.**",
};
/* DO NOT test HomeURI or ServiceURLs here, these are generated in a completely different code location */
m_Backend.Add(ua);
m_Log.Info("Testing retrieval by email");
ua = m_Service["*****@*****.**"];
if (!CheckTestData(ua))
{
return(false);
}
m_Log.Info("Testing retrieval by ID");
ua = m_Service[userID];
if (!CheckTestData(ua))
{
return(false);
}
m_Log.Info("Testing retrieval by name");
ua = m_Service["First", "Last"];
if (!CheckTestData(ua))
{
return(false);
}
return(true);
}
private bool TryAddAdditionalObject(SceneInterface scene, string sectionName)
{
IConfig config = m_Loader.Config.Configs[sectionName];
Vector3 position = Vector3.Parse(config.GetString("Position", m_Position.ToString()));
Quaternion rotation = Quaternion.Parse(config.GetString("Rotation", m_Rotation.ToString()));
UUID objectid = UUID.Parse(config.GetString("ID", UUID.Random.ToString()));
int scriptPin = config.GetInt("ScriptAccessPin", 0);
string objectName = config.GetString("ObjectName", sectionName);
string scriptName = config.GetString("ScriptName", "Script");
string experienceName = config.GetString("ExperienceName", "My Experience");
UUID itemID = UUID.Parse(config.GetString("ScriptItemID", UUID.Zero.ToString()));
UUID rezzingObjID = UUID.Parse(config.GetString("RezzingObjectID", UUID.Zero.ToString()));
UEI experienceID;
UUID expID;
UUID.TryParse(config.GetString("ExperienceID", m_ExperienceID.ToString()), out expID);
experienceID = new UEI(expID, experienceName, null);
string objectDescription = config.GetString("ObjectDescription", "");
string scriptDescription = config.GetString("ScriptDescription", "");
var objectOwner = new UGUIWithName(config.GetString("ObjectOwner", m_ObjectOwner.ToString()))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(objectOwner);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = objectOwner,
IsLocalToGrid = true,
});
}
catch
{
/* intentionally ignored */
}
var objectCreator = new UGUIWithName(config.GetString("ObjectCreator", m_ObjectCreator.ToString()))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(objectCreator);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = objectCreator,
IsLocalToGrid = true,
});
}
catch
{
/* intentionally ignored */
}
var objectLastOwner = new UGUIWithName(config.GetString("ObjectLastOwner", m_ObjectLastOwner.ToString()))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(objectLastOwner);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = objectLastOwner,
IsLocalToGrid = true,
});
}
catch
{
/* intentionally ignored */
}
var scriptOwner = new UGUIWithName(config.GetString("ScriptOwner", m_ScriptOwner.ToString()))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(scriptOwner);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = scriptOwner,
IsLocalToGrid = true,
});
}
catch
{
/* intentionally ignored */
}
var scriptCreator = new UGUIWithName(config.GetString("ScriptCreator", m_ScriptCreator.ToString()))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(scriptCreator);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = scriptCreator,
IsLocalToGrid = true,
});
}
catch
{
/* intentionally ignored */
}
var scriptLastOwner = new UGUIWithName(config.GetString("ScriptLastOwner", m_ScriptLastOwner.ToString()))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(scriptLastOwner);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = scriptLastOwner,
IsLocalToGrid = true,
});
}
catch
{
/* intentionally ignored */
}
int startParameter = config.GetInt("StartParameter", m_StartParameter);
InventoryPermissionsMask objectPermissionsBase = GetPermissions(config, "ObjectPermisionsBase", m_ObjectPermissionsBase);
InventoryPermissionsMask objectPermissionsOwner = GetPermissions(config, "ObjectPermisionsOwner", m_ObjectPermissionsOwner);
InventoryPermissionsMask objectPermissionsGroup = GetPermissions(config, "ObjectPermisionsGroup", m_ObjectPermissionsGroup);
InventoryPermissionsMask objectPermissionsNext = GetPermissions(config, "ObjectPermisionsNext", m_ObjectPermissionsNext);
InventoryPermissionsMask objectPermissionsEveryone = GetPermissions(config, "ObjectPermisionsEveryone", m_ObjectPermissionsEveryone);
InventoryPermissionsMask scriptPermissionsBase = GetPermissions(config, "ScriptPermisionsBase", m_ScriptPermissionsBase);
InventoryPermissionsMask scriptPermissionsOwner = GetPermissions(config, "ScriptPermisionsOwner", m_ScriptPermissionsOwner);
InventoryPermissionsMask scriptPermissionsGroup = GetPermissions(config, "ScriptPermisionsGroup", m_ScriptPermissionsGroup);
InventoryPermissionsMask scriptPermissionsNext = GetPermissions(config, "ScriptPermisionsNext", m_ScriptPermissionsNext);
InventoryPermissionsMask scriptPermissionsEveryone = GetPermissions(config, "ScriptPermisionsEveryone", m_ScriptPermissionsEveryone);
UUID assetID = UUID.Zero;
string scriptFile = string.Empty;
/* we use same asset id keying here so to make them compatible with the other scripts */
foreach (string key in config.GetKeys())
{
if (UUID.TryParse(key, out assetID))
{
scriptFile = config.GetString(key);
break;
}
}
IScriptAssembly scriptAssembly = null;
if (!string.IsNullOrEmpty(scriptFile))
{
if (itemID == UUID.Zero)
{
itemID = UUID.Random;
}
try
{
using (var reader = new StreamReader(scriptFile, new UTF8Encoding(false)))
{
scriptAssembly = CompilerRegistry.ScriptCompilers.Compile(AppDomain.CurrentDomain, UGUI.Unknown, m_AssetID, reader);
}
m_Log.InfoFormat("Compilation of {1} ({0}) successful", m_AssetID, scriptFile);
}
catch (CompilerException e)
{
m_Log.ErrorFormat("Compilation of {1} ({0}) failed: {2}", m_AssetID, scriptFile, e.Message);
m_Log.WarnFormat("Stack Trace:\n{0}", e.StackTrace.ToString());
return(false);
}
catch (Exception e)
{
m_Log.ErrorFormat("Compilation of {1} ({0}) failed: {2}", m_AssetID, scriptFile, e.Message);
m_Log.WarnFormat("Stack Trace:\n{0}", e.StackTrace.ToString());
return(false);
}
}
try
{
ExperienceServiceInterface experienceService = scene.ExperienceService;
if (null != experienceService)
{
ExperienceInfo test;
if (!experienceService.TryGetValue(experienceID, out test))
{
experienceService.Add(new ExperienceInfo
{
ID = experienceID,
Creator = scriptOwner,
Owner = scriptOwner,
Properties = ExperiencePropertyFlags.Grid /* make this grid-wide since otherwise we have to configure a lot more */
});
}
}
else
{
experienceID = UEI.Unknown;
}
}
catch (Exception e)
{
m_Log.Error("Creating experience failed", e);
return(false);
}
string[] additionalInventoryConfigs = config.GetString("AdditionalInventories", string.Empty).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (additionalInventoryConfigs.Length == 1 && additionalInventoryConfigs[0] == string.Empty)
{
additionalInventoryConfigs = new string[0];
}
try
{
var grp = new ObjectGroup
{
RezzingObjectID = rezzingObjID
};
var part = new ObjectPart(objectid);
grp.Add(1, part.ID, part);
part.ObjectGroup = grp;
grp.Owner = objectOwner;
grp.LastOwner = objectLastOwner;
part.Creator = objectCreator;
part.Name = objectName;
part.Description = objectDescription;
part.GlobalPosition = position;
part.GlobalRotation = rotation;
part.BaseMask = objectPermissionsBase;
part.OwnerMask = objectPermissionsOwner;
part.NextOwnerMask = objectPermissionsNext;
part.EveryoneMask = objectPermissionsEveryone;
part.GroupMask = objectPermissionsGroup;
part.ScriptAccessPin = scriptPin;
var item = new ObjectPartInventoryItem(itemID)
{
AssetType = AssetType.LSLText,
AssetID = assetID,
InventoryType = InventoryType.LSL,
LastOwner = scriptLastOwner,
Creator = scriptCreator,
Owner = scriptOwner,
Name = scriptName,
Description = scriptDescription
};
item.Permissions.Base = scriptPermissionsBase;
item.Permissions.Current = scriptPermissionsOwner;
item.Permissions.EveryOne = scriptPermissionsEveryone;
item.Permissions.Group = scriptPermissionsGroup;
item.Permissions.NextOwner = scriptPermissionsNext;
item.ExperienceID = experienceID;
scene.Add(grp);
foreach (string invconfig in additionalInventoryConfigs)
{
AddAdditionalInventory(part, invconfig);
}
if (scriptAssembly != null)
{
byte[] serializedState;
m_ScriptStates.TryGetValue(item.ID, out serializedState);
ScriptInstance scriptInstance = scriptAssembly.Instantiate(part, item, serializedState);
part.Inventory.Add(item);
item.ScriptInstance = scriptInstance;
item.ScriptInstance.Start(startParameter);
}
}
catch (Exception e)
{
m_Log.Error("Adding object failed", e);
return(false);
}
return(true);
}
public void Startup(ConfigurationLoader loader)
{
m_Scenes = loader.Scenes;
m_Loader = loader;
m_GatekeeperURI = loader.GatekeeperURI;
IConfig config = loader.Config.Configs[GetType().FullName];
/* we use same asset id keying here so to make them compatible with the other scripts */
foreach (string key in config.GetKeys())
{
if (UUID.TryParse(key, out m_AssetID))
{
m_ScriptFile = config.GetString(key);
break;
}
}
m_ObjectPermissionsBase = GetPermissions(config, "ObjectPermisionsBase");
m_ObjectPermissionsOwner = GetPermissions(config, "ObjectPermisionsOwner");
m_ObjectPermissionsGroup = GetPermissions(config, "ObjectPermisionsGroup");
m_ObjectPermissionsNext = GetPermissions(config, "ObjectPermisionsNext");
m_ObjectPermissionsEveryone = GetPermissions(config, "ObjectPermisionsEveryone");
m_ScriptPermissionsBase = GetPermissions(config, "ScriptPermisionsBase");
m_ScriptPermissionsOwner = GetPermissions(config, "ScriptPermisionsOwner");
m_ScriptPermissionsGroup = GetPermissions(config, "ScriptPermisionsGroup");
m_ScriptPermissionsNext = GetPermissions(config, "ScriptPermisionsNext");
m_ScriptPermissionsEveryone = GetPermissions(config, "ScriptPermisionsEveryone");
m_LoadOarFileName = config.GetString("OarFilename", string.Empty);
m_TimeoutMs = config.GetInt("RunTimeout", 1000);
m_RegionID = UUID.Parse(config.GetString("RegionID"));
m_RegionOwner = new UGUIWithName(config.GetString("RegionOwner"))
{
IsAuthoritative = true
};
m_EstateOwner = new UGUIWithName(config.GetString("EstateOwner", m_RegionOwner.ToString()))
{
IsAuthoritative = true
};
m_EstateID = (uint)config.GetInt("EstateID", 100);
m_EstateName = config.GetString("EstateName", "My Estate");
m_ObjectID = UUID.Parse(config.GetString("ID", UUID.Random.ToString()));
m_RegionName = config.GetString("RegionName", "Testing Region");
m_ProductName = config.GetString("RegionProductName", "Mainland");
m_RegionLocation = new GridVector(config.GetString("RegionLocation", "10000,10000"), 256);
m_RegionSize = new GridVector(config.GetString("RegionSize", "1,1"), 256);
m_RegionAccess = (RegionAccess)Enum.Parse(typeof(RegionAccess), config.GetString("RegionAccess", "PG"));
m_RegionPort = config.GetInt("RegionPort", 9300);
m_Runner = loader.GetServicesByValue <TestRunner>()[0];
m_Position = Vector3.Parse(config.GetString("Position", "<128, 128, 23>"));
m_Rotation = Quaternion.Parse(config.GetString("Rotation", "<0,0,0,1>"));
m_ItemID = UUID.Parse(config.GetString("ScriptItemID", UUID.Random.ToString()));
m_RezzingObjID = UUID.Parse(config.GetString("RezzingObjectID", UUID.Zero.ToString()));
m_ObjectName = config.GetString("ObjectName", "Object");
m_ScriptName = config.GetString("ScriptName", "Script");
string experienceName = config.GetString("ExperienceName", "My Experience");
UUID experienceID;
UUID.TryParse(config.GetString("ExperienceID", UUID.Zero.ToString()), out experienceID);
m_ExperienceID = new UEI(experienceID, experienceName, null);
m_ObjectDescription = config.GetString("ObjectDescription", "");
m_ScriptDescription = config.GetString("ScriptDescription", "");
m_RegionStorage = loader.GetService <GridServiceInterface>("RegionStorage");
m_SceneFactory = loader.GetService <SceneFactoryInterface>("DefaultSceneImplementation");
m_EstateService = loader.GetService <EstateServiceInterface>("EstateService");
m_AvatarNameService = loader.GetService <AvatarNameServiceInterface>("AvatarNameStorage");
m_UserAccountService = loader.GetService <UserAccountServiceInterface>("UserAccountService");
m_AvatarNameService.Store(m_RegionOwner);
m_AvatarNameService.Store(m_EstateOwner);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = m_RegionOwner,
IsLocalToGrid = true,
});
}
catch
{
m_Log.Info("UserAccount creation failed for RegionOwner");
}
if (!m_EstateOwner.EqualsGrid(m_RegionOwner))
{
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = m_RegionOwner,
IsLocalToGrid = true,
});
}
catch
{
m_Log.Info("UserAccount creation failed for EstateOwner");
}
}
m_ObjectOwner = new UGUIWithName(config.GetString("ObjectOwner"))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(m_ObjectOwner);
if (config.Contains("ObjectCreator"))
{
m_ObjectCreator = new UGUIWithName(config.GetString("ObjectCreator"))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(m_ObjectCreator);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = m_ObjectCreator,
IsLocalToGrid = true,
});
}
catch
{
/* intentionally ignored */
}
}
else
{
m_ObjectCreator = m_ObjectOwner;
}
if (config.Contains("ObjectLastOwner"))
{
m_ObjectLastOwner = new UGUIWithName(config.GetString("ObjectLastOwner"))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(m_ObjectLastOwner);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = m_ObjectLastOwner,
IsLocalToGrid = true,
});
}
catch
{
/* intentionally ignored */
}
}
else
{
m_ObjectLastOwner = m_ObjectOwner;
}
m_ScriptOwner = new UGUIWithName(config.GetString("ScriptOwner"))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(m_ScriptOwner);
if (config.Contains("ScriptCreator"))
{
m_ScriptCreator = new UGUIWithName(config.GetString("ScriptCreator"))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(m_ScriptCreator);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = m_ScriptCreator,
IsLocalToGrid = true,
});
}
catch
{
/* intentionally ignored */
}
}
else
{
m_ScriptCreator = m_ScriptOwner;
}
if (config.Contains("ScriptLastOwner"))
{
m_ScriptLastOwner = new UGUIWithName(config.GetString("ScriptLastOwner"))
{
IsAuthoritative = true
};
m_AvatarNameService.Store(m_ScriptLastOwner);
try
{
m_UserAccountService.Add(new UserAccount
{
Principal = m_ScriptLastOwner,
IsLocalToGrid = true,
});
}
catch
{
/* intentionally ignored */
}
}
else
{
m_ScriptLastOwner = m_ScriptOwner;
}
m_StartParameter = config.GetInt("StartParameter", 0);
if (string.IsNullOrEmpty(m_ScriptFile))
{
throw new ArgumentException("Script filename and UUID missing");
}
m_AdditionalObjectConfigs = config.GetString("AdditionalObjects", string.Empty).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (m_AdditionalObjectConfigs.Length == 1 && m_AdditionalObjectConfigs[0] == string.Empty)
{
m_AdditionalObjectConfigs = new string[0];
}
m_AdditionalInventoryConfigs = config.GetString("AdditionalInventories", string.Empty).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (m_AdditionalInventoryConfigs.Length == 1 && m_AdditionalInventoryConfigs[0] == string.Empty)
{
m_AdditionalInventoryConfigs = new string[0];
}
m_AssetSourcesConfig = config.GetString("AssetSources", string.Empty);
m_ScriptStatesConfig = config.GetString("ScriptStates", string.Empty);
CompilerRegistry.ScriptCompilers.DefaultCompilerName = config.GetString("DefaultCompiler");
}
private void HandleUserAccountCreate(HttpRequest req, Map jsondata)
{
var account = new UserAccount();
account.Principal.ID = UUID.Random;
string firstname;
string lastname;
string password;
if (!jsondata.TryGetValue("firstname", out firstname) ||
!jsondata.TryGetValue("lastname", out lastname) ||
!jsondata.TryGetValue("password", out password))
{
m_WebIF.ErrorResponse(req, AdminWebIfErrorResult.InvalidRequest);
return;
}
account.Principal.FirstName = firstname;
account.Principal.LastName = lastname;
int ival;
string sval;
uint uval;
if (jsondata.TryGetValue("userlevel", out ival))
{
account.UserLevel = ival;
if (account.UserLevel > 255)
{
m_WebIF.ErrorResponse(req, AdminWebIfErrorResult.InvalidParameter);
return;
}
}
if (jsondata.TryGetValue("usertitle", out sval))
{
account.UserTitle = sval;
}
if (jsondata.TryGetValue("userflags", out uval))
{
account.UserFlags = (UserFlags)uval;
}
if (jsondata.TryGetValue("email", out sval))
{
account.Email = sval;
}
try
{
m_UserAccountService.Add(account);
}
catch
{
m_WebIF.ErrorResponse(req, AdminWebIfErrorResult.AlreadyExists);
return;
}
var uai = new UserAuthInfo
{
ID = account.Principal.ID,
Password = password
};
try
{
m_AuthInfoService.Store(uai);
}
catch
{
m_UserAccountService.Remove(account.Principal.ID);
m_WebIF.ErrorResponse(req, AdminWebIfErrorResult.NotPossible);
return;
}
var res = new Map
{
{ "id", account.Principal.ID },
{ "firstname", account.Principal.FirstName },
{ "lastname", account.Principal.LastName }
};
var resdata = new Map
{
["account"] = res
};
m_WebIF.SuccessResponse(req, resdata);
}
