public void Execute(DocumentDatabase database)
{
if (string.IsNullOrEmpty(database.Name) == false)
return;// we don't care about tenant databases
if (string.Equals(database.Configuration.AuthenticationMode, "OAuth", StringComparison.InvariantCultureIgnoreCase) == false)
return; // we don't care if we aren't using oauth
var array = database.GetDocumentsWithIdStartingWith("Raven/Users/", 0, 1);
if (array.Length > 0)
return; // there is already at least one user in there
var pwd = Guid.NewGuid().ToString();
if (database.Configuration.RunInMemory == false)
{
var authConfigPath = Path.Combine(Path.GetDirectoryName(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile), "authentication.config");
File.WriteAllText(authConfigPath,
@"Since no users were found in the database, and the database authentication mode was set to OAuth, the following user was automatically created.
Username: Admin
Password: "******"
You can use those credentials to login to RavenDB.");
logger.Info(@"Since no users were found, and the database authentication mode was set to OAuth, a default user was generated name 'Admin'.
Credentials for this user can be found in the following file: {0}", authConfigPath);
}
var ravenJTokenWriter = new RavenJTokenWriter();
JsonExtensions.CreateDefaultJsonSerializer().Serialize(ravenJTokenWriter, new AuthenticationUser
{
AllowedDatabases = new[] { "*" },
Name = "Admin",
Admin = true
}.SetPassword(pwd));
var userDoc = (RavenJObject)ravenJTokenWriter.Token;
userDoc.Remove("Id");
database.Put("Raven/Users/Admin", null,
userDoc,
new RavenJObject
{
{Constants.RavenEntityName, "AuthenticationUsers"},
{
Constants.RavenClrType,
typeof (AuthenticationUser).FullName + ", " + typeof (AuthenticationUser).Assembly.GetName().Name
}
}, null);
}
internal static RavenJToken FromObjectInternal(object o, JsonSerializer jsonSerializer)
{
var ravenJToken = o as RavenJToken;
if (ravenJToken != null)
{
return(ravenJToken);
}
RavenJToken token;
using (var jsonWriter = new RavenJTokenWriter())
{
jsonSerializer.Serialize(jsonWriter, o);
token = jsonWriter.Token;
}
return(token);
}
internal static RavenJToken FromObjectInternal(object o, JsonSerializer jsonSerializer)
{
ValidationUtils.ArgumentNotNull(o, "o");
ValidationUtils.ArgumentNotNull(jsonSerializer, "jsonSerializer");
var ravenJToken = o as RavenJToken;
if (ravenJToken != null)
{
return(ravenJToken);
}
RavenJToken token;
using (var jsonWriter = new RavenJTokenWriter())
{
jsonSerializer.Serialize(jsonWriter, o);
token = jsonWriter.Token;
}
return(token);
}
private RavenJObject GetMappedData(object doc)
{
if (doc is IDynamicJsonObject)
return ((IDynamicJsonObject)doc).Inner;
var ravenJTokenWriter = new RavenJTokenWriter();
jsonSerializer.Serialize(ravenJTokenWriter, doc);
return (RavenJObject)ravenJTokenWriter.Token;
}
private IEnumerable<object> DefaultApplyReduceFunction(
Type indexType,
Type resultType,
IEnumerable<object> results,
Func<Func<IEnumerable<object>, IEnumerable>> generateTransformResults)
{
Func<IEnumerable<object>, IEnumerable> compile;
if(compiledReduceCache.TryGetValue(indexType, out compile) == false)
{
compile = generateTransformResults();
compiledReduceCache = new Dictionary<Type, Func<IEnumerable<object>, IEnumerable>>(compiledReduceCache)
{
{indexType, compile}
};
}
return compile(results).Cast<object>()
.Select(result =>
{
// we got an anonymous object and we need to get the reduce results
var ravenJTokenWriter = new RavenJTokenWriter();
var jsonSerializer = CreateSerializer();
jsonSerializer.Serialize(ravenJTokenWriter, result);
return jsonSerializer.Deserialize(new RavenJTokenReader(ravenJTokenWriter.Token), resultType);
});
}
private static RavenJObject GetJson(IFilter filter)
{
// initialize a buffer for text results
const int defaultBufferSize = 4096;
var buffer = new StringBuilder(defaultBufferSize);
// Initialize the json writers
using (var textWriter = new RavenJTokenWriter())
using (var propWriter = new RavenJTokenWriter())
{
// Write the beginning of the json arrays
textWriter.WriteStartArray();
propWriter.WriteStartArray();
string last = null;
// Outer loop will read chunks from the document.
// For those chunks that have text, the contents will be written to json.
while (true)
{
// Try to get a chunk of data
STAT_CHUNK statChunk;
var chunkStatus = filter.GetChunk(out statChunk);
switch (chunkStatus)
{
case IFilterReturnCodes.S_OK:
// We have a good chunk of data
break;
case IFilterReturnCodes.FILTER_E_END_OF_CHUNKS:
// No more data.
if (buffer.Length > 0)
{
// Make sure we have no unwritten data first.
textWriter.WriteLines(buffer.ToString());
buffer.Clear();
}
// close the json array and flush the writers
textWriter.WriteEndArray();
propWriter.WriteEndArray();
textWriter.Flush();
propWriter.Flush();
// assemble and return the document
return new RavenJObject
{
//{ "Properties", propWriter.Token }, // TODO: restore this when properties can be retrieved
{ "Text", textWriter.Token }
};
case IFilterReturnCodes.FILTER_E_EMBEDDING_UNAVAILABLE:
case IFilterReturnCodes.FILTER_E_LINK_UNAVAILABLE:
// Ignore these warnings
continue;
default:
// Something else - throw an exception
throw new COMException("IFilter COM error while getting a chunk of data: " + chunkStatus);
}
//// Handle property value chunks TODO: make this work so we can index properties in addition to text
//if (statChunk.flags.HasFlag(CHUNKSTATE.CHUNK_VALUE))
//{
// // get the property name TODO: This doesn't seem to work
// var propInfo = statChunk.attribute.psProperty;
// var propName = propInfo.ulKind == 0 ? Marshal.PtrToStringAuto(propInfo.lpwstr) : propInfo.propid.ToString();
//
// // will this help?
// var propGuid = statChunk.attribute.guidPropSet;
// // get the value TODO: This doesn't seem to work
// PROPVARIANT ppPropValue;
// var valueStatus = filter.GetValue(out ppPropValue);
// if (valueStatus == IFilterReturnCodes.S_OK || valueStatus == IFilterReturnCodes.FILTER_S_LAST_VALUES)
// {
// // write the value to json
// propWriter.WriteStartObject();
// propWriter.WritePropertyName(propName);
// propWriter.WriteValue(ppPropValue.Value);
// propWriter.WriteEndObject();
// // free unmanaged memory from the PropVariant
// ppPropValue.Clear();
// }
//}
// the rest of this code is for text chunks only
if (!statChunk.flags.HasFlag(CHUNKSTATE.CHUNK_TEXT))
continue;
// Check for white space items and add the appropriate breaks.
switch (statChunk.breakType)
{
case CHUNK_BREAKTYPE.CHUNK_EOW:
if (buffer.Length > 0 && !char.IsWhiteSpace(buffer[buffer.Length - 1]))
buffer.Append(' ');
break;
case CHUNK_BREAKTYPE.CHUNK_EOC:
case CHUNK_BREAKTYPE.CHUNK_EOP:
case CHUNK_BREAKTYPE.CHUNK_EOS:
// Each chapter, paragraph or sentence break can be in a new json value in our array.
// This will keep any one string from getting too big.
if (buffer.Length > 0)
{
textWriter.WriteLines(buffer.ToString());
buffer.Clear();
}
break;
}
while (true)
{
// Create a temporary string buffer we can use for the parsing algorithm.
int cBuffer = defaultBufferSize;
var sbBuffer = new StringBuilder(defaultBufferSize);
// Read the next piece of data up to the size of our local buffer.
var textStatus = filter.GetText(ref cBuffer, sbBuffer);
if (textStatus == IFilterReturnCodes.S_OK || textStatus == IFilterReturnCodes.FILTER_S_LAST_TEXT)
{
// If any data was returned, add it to the buffer.
buffer.Append(sbBuffer.ToString(), 0, cBuffer);
}
// Once all data is exhausted, we are done so terminate the loop.
if (textStatus == IFilterReturnCodes.FILTER_S_LAST_TEXT || textStatus == IFilterReturnCodes.FILTER_E_NO_MORE_TEXT)
break;
}
}
}
}