public static int initialize(string mapReferenceFile)
{
// Indicates the number of maps loaded successfully
int loadedMaps=0;
XmlData doc=new XmlData(mapReferenceFile);
if(doc.ExistElement("maps")==false)
{
Logger.Write(LogLevel.Error, "Item Manager: Error while parsing map database ({0})!", mapReferenceFile);
return loadedMaps;
}
Logger.Write(LogLevel.Information, "Loading map reference: {0}", mapReferenceFile);
//Für jeden Mapknoten
List<XmlNode> nodes=doc.GetElements("maps.map");
foreach(XmlNode node in nodes)
{
if(node.Name!="map") continue;
int id=Convert.ToInt32(node.Attributes["id"].Value);
string name=node.Attributes["name"].Value;
if(id>0&&name!="")
{
// Testing if the file is actually in the maps folder
string file="maps/"+name+".tmx";
bool mapFileExists=ResourceManager.exists(file);
if(mapFileExists)
{
maps[id]=new MapComposite(id, name);
++loadedMaps;
}
}
else
{
if(name=="")
{
Logger.Write(LogLevel.Warning, "Invalid unnamed map Id: {0}.", id);
}
else
{
Logger.Write(LogLevel.Warning, "Invalid map Id: {0}.", id);
}
}
}
if(loadedMaps>0)
{
Logger.Write(LogLevel.Information, "{0} valid map file references were loaded.", loadedMaps);
}
return loadedMaps;
}
public Highscore(string path)
{
highscorePath=path;
if(FileSystem.ExistsFile(highscorePath))
{
XmlData scoreFile=new XmlData(highscorePath);
List<XmlNode> scoreNodes=scoreFile.GetElements("xml.Score");
foreach(XmlNode scoreNode in scoreNodes)
{
string name=scoreNode.Attributes["name"]!=null?scoreNode.Attributes["name"].Value:"";
int value=scoreNode.Attributes["value"]!=null?Convert.ToInt32(scoreNode.Attributes["value"].Value):0;
userHighscore.Add(name, value);
}
}
}
public static void Main(string[] args)
{
//Options
if(!FileSystem.ExistsFile("config.xml"))
{
Console.WriteLine("No config.xml file found.");
return;
}
XmlData Options=new XmlData("config.xml");
recieverMail=Options.GetElementAsString("xml.SMTP.RecieverMail");
smtpserver=Options.GetElementAsString("xml.SMTP.Server");
senderMail=Options.GetElementAsString("xml.SMTP.SenderMail");
smtpUsername=Options.GetElementAsString("xml.SMTP.Username");
smtpPassword=Options.GetElementAsString("xml.SMTP.Password");
//Files
Dictionary<string, string> commandLine=CommandLineHelpers.GetCommandLine(args);
List<string> files=new List<string>();
bool book=commandLine.ContainsKey("book");
string bookname = "";
if(book) bookname = commandLine["book"];
List<string> clFiles=CommandLineHelpers.GetFilesFromCommandline(commandLine);
foreach(string clFile in clFiles)
{
if(FileSystem.IsFile(clFile))
{
files.Add(clFile);
}
else
{
files.AddRange(FileSystem.GetFiles(clFile, true));
}
}
if(files.Count==0)
{
Console.WriteLine("No files specified.");
return;
}
//Send Files
foreach(string file in files)
{
string fileSend=file;
//CSCL.
//Sending
string subject=FileSystem.GetFilenameWithoutExt(file);
if(book)
{
subject = String.Format("{0} @{1}", subject, bookname);
}
Console.WriteLine("Send file {0}...", FileSystem.GetFilename(file));
SMTP.SendMailMessageWithAuthAndAttachment(smtpserver, smtpUsername, smtpPassword, senderMail, "everloaduploader", recieverMail, recieverMail, subject, "", fileSend);
}
}
public static void Init(string filename)
{
if(filename==null||filename=="")
{
Filename=DEFAULT_CONFIG_FILE;
}
else
{
Filename=filename;
}
if(!FileSystem.ExistsFile(Filename)) throw new Exception();
xmlfile=new XmlData(Filename);
nodes=xmlfile.GetElements("configuration.option");
}
static void Main(string[] args)
{
if(args.Length!=1)
{
Console.WriteLine("Please set a config file!");
return;
}
//CancelEvent verdrahten
Console.CancelKeyPress+=new ConsoleCancelEventHandler(Console_CancelKeyPress);
//Highscore Pfad bauen
string highscorePath=FileSystem.GetPath(args[0])+"highscore.xml";
//Config auslesen
XmlData Options=new XmlData(args[0]);
string username=Options.GetElementAsString("xml.IRC.UserName");
string realname=Options.GetElementAsString("xml.IRC.RealName");
string ident=Options.GetElementAsString("xml.IRC.Ident");
string server=Options.GetElementAsString("xml.IRC.Server");
string channel=Options.GetElementAsString("xml.IRC.Channel");
string userpassword=Options.GetElementAsString("xml.IRC.Password");
//Bot anlegen
Arbiter arbiter=new Arbiter(server, username, realname, ident, channel, highscorePath);
//Jokes einlesen
List<XmlNode> jokeNodes=Options.GetElements("xml.Jokes.Joke");
foreach(XmlNode jokeNode in jokeNodes)
{
string category=jokeNode.Attributes["category"]!=null?jokeNode.Attributes["category"].Value:"";
string jokeText=jokeNode.InnerText;
arbiter.Jokes.Add(new Joke(category, jokeText));
}
//Quizfragen einlesen
List<XmlNode> questionsNodes=Options.GetElements("xml.Quiz.Question");
foreach(XmlNode questionNode in questionsNodes)
{
string category=questionNode.Attributes["category"].Value;
string question=questionNode.Attributes["question"].Value;
string success=questionNode.Attributes["success"]!=null?questionNode.Attributes["success"].Value:"";
int points=Convert.ToInt32(questionNode.Attributes["points"].Value);
List<string> hints=new List<string>();
int keywordWeight=1;
if(questionNode.Attributes.GetNamedItem("keywordWeight")!=null)
{
keywordWeight=Convert.ToInt32(questionNode.Attributes["keywordWeight"].Value);
}
List<Keyword> keywords=new List<Keyword>();
foreach(XmlNode child in questionNode.ChildNodes)
{
if(child.Name=="Keyword")
{
int weight=1;
if(child.Attributes.GetNamedItem("keywordWeight")!=null)
{
string weightValue=child.Attributes["keywordWeight"].Value;
if(weightValue=="MAX")
weight=Int32.MaxValue;
else
weight=Convert.ToInt32(weightValue);
}
Keyword keyword=new Keyword(child.InnerText, weight);
keywords.Add(keyword);
}
else if(child.Name=="Hint")
{
hints.Add(child.InnerText);
}
}
//Frage zum Bot hinzufügen
arbiter.Quiz.Questions.Add(new Question(category, question, hints, success, points, keywordWeight, keywords));
}
//Quotes einlesen
List<XmlNode> quodeNodes=Options.GetElements("xml.Quotes.Quote");
foreach(XmlNode quodeNode in quodeNodes)
{
string author=quodeNode.Attributes["author"].Value;
string quoteText=quodeNode.InnerText;
arbiter.Quotes.Add(new Quote(author, quoteText));
}
//Bot starten
arbiter.Start(userpassword);
}
public static void Main(string[] args)
{
//Load config
XmlData config;
try
{
config=new XmlData("tweetstatus.xml");
}
catch(Exception e)
{
Console.WriteLine("Konfiguration konnte nicht gelesen werden.");
Console.WriteLine(e.ToString());
return;
}
string miscCheckCertificates=config.GetElementAsString("xml.misc.checkcertificates");
if(miscCheckCertificates.ToLower()=="false")
{
//Disable certificate check
ServicePointManager.ServerCertificateValidationCallback=delegate
{
return true;
};
}
string apiToken=config.GetElementAsString("xml.api.token");
string apiUrl=config.GetElementAsString("xml.api.url");
string twitterConsumerKey=config.GetElementAsString("xml.twitter.consumerkey");
string twitterConsumerSecret=config.GetElementAsString("xml.twitter.consumersecret");
string twitterAccessToken=config.GetElementAsString("xml.twitter.accesstoken");
string twitterAccessTokenSecret=config.GetElementAsString("xml.twitter.accesstokensecret");
//Create twitter token
OAuthInfo token=null;
if(twitterAccessToken==""||twitterAccessTokenSecret=="")
{
Console.WriteLine("Set access token in config file");
return;
}
else
{
token=new OAuthInfo {
AccessToken=twitterAccessToken,
AccessSecret=twitterAccessTokenSecret,
ConsumerKey=twitterConsumerKey,
ConsumerSecret=twitterConsumerSecret
};
}
//Check status database
Console.WriteLine("Check status database");
//Database
RestClient client=new RestClient(apiUrl);
string parameters=String.Format("entities/?token={0}", apiToken);
string value=client.Request(parameters);
int entityCount=Convert.ToInt32(value);
Console.WriteLine("Entity count from api: {0}", entityCount);
//Check status file and tweet if nessesary
//Load known entries
string entryFile="status.txt";
Entry oldStatus=new Entry(0);
if(File.Exists(entryFile))
{
oldStatus=new Entry(File.ReadAllLines(entryFile)[0]);
}
Entry newStatus=new Entry(entityCount);
if(oldStatus!=newStatus)
{
//Tweet
DateTime now=DateTime.Now;
string datetimeHash="#"+CRC16.ComputeChecksum(BitConverter.GetBytes(now.Ticks)).ToString("x4");
string statusGreen=String.Format("Der Hackerspace ist besetzt ({0}:{1:00} Uhr) und kann besucht werden. #status {2}", now.Hour, now.Minute, datetimeHash);
string statusYellow="";
string statusRed=String.Format("Der Hackerspace ist nicht mehr besetzt ({0}:{1:00} Uhr). #status {2}", now.Hour, now.Minute, datetimeHash);
string tweetText="";
if(newStatus.EntityCount==0)
{
tweetText=statusRed;
}
else
{
if(oldStatus.EntityCount>0)
{
Console.WriteLine("Update not necessary.");
return;
}
tweetText=statusGreen;
}
bool success=true;
try
{
Console.WriteLine("Token: {0}", token.ToString());
var twitter=new TinyTwitter.TinyTwitter(token);
twitter.UpdateStatus(tweetText);
}
catch(Exception ex)
{
Console.WriteLine(ex.ToString());
success=false;
}
if(success)
{
//Write success on console
Console.WriteLine("Tweet sended: {0}", tweetText);
//Write new status
File.WriteAllText(entryFile, newStatus.ToString());
}
else
{
Console.WriteLine("Tweet not sended: {0}", tweetText);
}
}
}
public static void Main(string[] args)
{
//Console
Console.WriteLine("Initializing sensor...");
//Load config
XmlData config;
try
{
config=new XmlData("sensor.xml");
}
catch(Exception e)
{
Console.WriteLine("Konfiguration konnte nicht gelesen werden.");
Console.WriteLine(e.ToString());
return;
}
bool miscCheckCertificates=Convert.ToBoolean(config.GetElementAsString("xml.misc.checkcertificates"));
if(miscCheckCertificates==false)
{
//Disable certificate check
ServicePointManager.ServerCertificateValidationCallback=delegate
{
return true;
};
}
bool verbose=Convert.ToBoolean(config.GetElementAsString("xml.misc.verbose"));
string apiToken=config.GetElementAsString("xml.api.token");
string apiUrl=config.GetElementAsString("xml.api.url");
//EAPI Setup
EAPI eAPI=new EAPI(apiUrl, apiToken);
#region Network scan
Console.WriteLine("Scan network...");
//Scan network
Dictionary<string, List<NetworkEntry>> networkScans=new Dictionary<string, List<NetworkEntry>>();
List<XmlNode> networkSegments=config.GetElements("xml.network.segment");
foreach(XmlNode node in networkSegments)
{
bool active=Convert.ToBoolean(node["active"].InnerText);
if(!active) continue;
string key=node.Attributes["key"].Value;
Console.WriteLine("Scan network segment {0}...", key);
//IP Ranges
List<string> segmentIPRanges=new List<string>();
foreach(XmlNode childNode in node.ChildNodes)
{
if(childNode.LocalName=="iprange") segmentIPRanges.Add(childNode.InnerText);
}
//Scan ranges
List<NetworkEntry> entries=new List<NetworkEntry>();
foreach(string segmentIPRange in segmentIPRanges)
{
NetworkScanner scanner=new NetworkScanner();
List<NetworkEntry> segmentEntries=scanner.GetNetworkInformation(segmentIPRange);
Console.WriteLine("Detected network devices in segment {0}/{1}: {2}", key, segmentIPRange, segmentEntries.Count);
if(verbose)
{
foreach(NetworkEntry networkEntry in segmentEntries)
{
Console.WriteLine("Detected network device: {0} / {1} ({2}, {3} ms)", networkEntry.IP, networkEntry.Hostname, networkEntry.Up?"online":"offline", networkEntry.RoundtripTime);
}
}
entries.AddRange(segmentEntries);
}
networkScans.Add(key, entries);
}
#endregion
#region Detection
Console.WriteLine("Start detection...");
//Entity Detection
int countEntities=0;
bool entityDetection=Convert.ToBoolean(config.GetElementAsString("xml.detection.entity.active"));
if(entityDetection)
{
Console.WriteLine("Start entity detection...");
string sensorType=config.GetElementAsString("xml.detection.entity.sensortype");
string networkSegment=config.GetElementAsString("xml.detection.entity.networksegment");
int minimumCount=Convert.ToInt32(config.GetElementAsString("xml.detection.entity.minimumcount"));
TimeSpan minimumTime=new TimeSpan(0, 0, Convert.ToInt32(config.GetElementAsString("xml.detection.entity.minimumtime")));
long significantTimeAsLong=Convert.ToInt64(config.GetElementAsString("xml.detection.entity.significanttime"));
DateTime significantTime=new DateTime(significantTimeAsLong);
if(sensorType=="network")
{
Console.WriteLine("Start entity detection with sensor type network...");
if(networkScans.ContainsKey(networkSegment))
{
List<NetworkEntry> segmentEntries=networkScans[networkSegment];
//Check if minimum count is reached
if(segmentEntries.Count>minimumCount)
{
if(significantTimeAsLong==0)
{
significantTime=DateTime.Now;
config.WriteElement("xml.detection.entity.significanttime", significantTime.Ticks.ToString());
}
//Check if minimum time is reached
if(DateTime.Now>significantTime+minimumTime)
{
countEntities=segmentEntries.Count;
}
}
else
{
config.WriteElement("xml.detection.entity.significanttime", "0");
}
}
else
{
Console.WriteLine("Network segment for detection not found.");
}
}
}
#endregion
#region API
Console.WriteLine("Transfer sensor data to API...");
//Write Network informations into API Database
int countDevices=0;
foreach(KeyValuePair<string, List<NetworkEntry>> pair in networkScans)
{
countDevices+=pair.Value.Count;
eAPI.SetStatus(pair.Key, pair.Value.Count);
}
eAPI.SetStatus("devices", countDevices);
//Write Entites
eAPI.SetStatus("entities", countEntities);
#endregion
//set last run
config.WriteElement("xml.misc.lastrun", DateTime.Now.Ticks.ToString());
config.Save();
}
void Save()
{
XmlData scoreFile=new XmlData(highscorePath, true);
XmlNode root=scoreFile.AddRoot("xml");
foreach(KeyValuePair<string, int> pair in userHighscore)
{
XmlNode score=scoreFile.AddElement(root, "Score");
scoreFile.AddAttribute(score, "name", pair.Key);
scoreFile.AddAttribute(score, "value", pair.Value);
}
scoreFile.Save();
}
public void Save(string filename, bool compressed=true)
{
XmlData fileData=new XmlData();
#region Root speichern und Attribute anhängen
XmlNode root=fileData.AddRoot("map");
fileData.AddAttribute(root, "version", MapVersion);
fileData.AddAttribute(root, "orientation", Orientation);
fileData.AddAttribute(root, "width", Width);
fileData.AddAttribute(root, "height", Height);
fileData.AddAttribute(root, "tilewidth", TileWidth);
fileData.AddAttribute(root, "tileheight", TileHeight);
#endregion
#region Properties speichern
if(Properties.Count>0)
{
XmlNode properties=fileData.AddElement(root, "properties");
foreach(Property prop in Properties)
{
XmlNode propertyXml=fileData.AddElement(properties, "property");
fileData.AddAttribute(propertyXml, "name", prop.Name);
fileData.AddAttribute(propertyXml, "value", prop.Value);
}
}
#endregion
#region Tilesets
foreach(TilesetData tileset in Tilesets)
{
XmlNode tilesetXml=fileData.AddElement(root, "tileset");
fileData.AddAttribute(tilesetXml, "firstgid", tileset.firstgid);
fileData.AddAttribute(tilesetXml, "name", tileset.name);
fileData.AddAttribute(tilesetXml, "tilewidth", tileset.tilewidth);
fileData.AddAttribute(tilesetXml, "tileheight", tileset.tileheight);
XmlNode imageTag=fileData.AddElement(tilesetXml, "image");
fileData.AddAttribute(imageTag, "source", tileset.imgsource);
foreach(Tile tile in tileset.Tiles)
{
XmlNode tileTag=fileData.AddElement(tilesetXml, "tile");
fileData.AddAttribute(tileTag, "id", tile.ID);
if(tile.Properties.Count>0)
{
XmlNode properties=fileData.AddElement(tileTag, "properties");
foreach(Property prop in tile.Properties)
{
XmlNode propertyXml=fileData.AddElement(properties, "property");
fileData.AddAttribute(propertyXml, "name", prop.Name);
fileData.AddAttribute(propertyXml, "value", prop.Value);
}
}
}
}
#endregion
#region Layer
foreach(LayerData layer in Layers)
{
XmlNode layerXml=fileData.AddElement(root, "layer");
fileData.AddAttribute(layerXml, "name", layer.name);
fileData.AddAttribute(layerXml, "width", layer.width);
fileData.AddAttribute(layerXml, "height", layer.height);
XmlNode dataTag=fileData.AddElement(layerXml, "data", ConvertLayerDataToString(layer, compressed));
fileData.AddAttribute(dataTag, "encoding", "base64");
if(compressed)
{
fileData.AddAttribute(dataTag, "compression", "gzip");
}
}
#endregion
#region Objectlayer
foreach(Objectgroup objGroup in ObjectLayers)
{
XmlNode objGroupXml=fileData.AddElement(root, "objectgroup");
fileData.AddAttribute(objGroupXml, "name", objGroup.Name);
fileData.AddAttribute(objGroupXml, "width", objGroup.Width);
fileData.AddAttribute(objGroupXml, "height", objGroup.Height);
fileData.AddAttribute(objGroupXml, "x", objGroup.X);
fileData.AddAttribute(objGroupXml, "y", objGroup.Y);
foreach(Object obj in objGroup.Objects)
{
XmlNode objXml=fileData.AddElement(objGroupXml, "object");
fileData.AddAttribute(objXml, "name", obj.Name);
fileData.AddAttribute(objXml, "type", obj.Type);
fileData.AddAttribute(objXml, "x", obj.X);
fileData.AddAttribute(objXml, "y", obj.Y);
fileData.AddAttribute(objXml, "width", obj.Width);
fileData.AddAttribute(objXml, "height", obj.Height);
XmlNode objPropertiesXml=fileData.AddElement(objXml, "properties");
foreach(Property objProp in obj.Properties)
{
XmlNode propertyXml=fileData.AddElement(objPropertiesXml, "property");
fileData.AddAttribute(propertyXml, "name", objProp.Name);
fileData.AddAttribute(propertyXml, "value", objProp.Value);
}
}
}
#endregion
fileData.Save(filename);
}
void Open(string filename, bool loadTilesets)
{
//Datei öffnen
Tilesets=new List<TilesetData>();
Layers=new List<LayerData>();
ObjectLayers=new List<Objectgroup>();
Properties=new List<Property>();
//XMLdata öffnen
FileData=new XmlData(filename);
#region MapsInfo ermitteln
XmlNodeList xnl=FileData.Document.SelectNodes("/map");
MapVersion=xnl[0].Attributes["version"].Value;
Orientation=xnl[0].Attributes["orientation"].Value;
Width=Convert.ToInt32(xnl[0].Attributes["width"].Value);
Height=Convert.ToInt32(xnl[0].Attributes["height"].Value);
TileWidth=Convert.ToInt32(xnl[0].Attributes["tilewidth"].Value);
TileHeight=Convert.ToInt32(xnl[0].Attributes["tileheight"].Value);
#endregion
#region Properties auslesen
xnl=FileData.Document.SelectNodes("/map/properties");
foreach(XmlNode j in xnl)
{
XmlNodeList subnodes=j.SelectNodes("child::property");
foreach(XmlNode pNode in subnodes)
{
string name=pNode.Attributes[0].Name;
string value=pNode.Attributes[0].Value;
Properties.Add(new Property(pNode));
}
}
#endregion
#region Tilesets ermitteln
xnl=FileData.Document.SelectNodes("/map/tileset");
foreach(XmlNode j in xnl)
{
//Tilesets
TilesetData ts=new TilesetData();
ts.imgsource=j.SelectNodes("child::image")[0].Attributes[0].Value; //Image Source für den Layer
string imgsourceComplete=FileSystem.GetPath(filename)+ts.imgsource;
//Tiles laden, wenn vorhanden
XmlNodeList nodelist=j.SelectNodes("child::tile");
foreach(XmlNode tileXml in nodelist)
{
Tile tile=new Tile();
tile.ID=tileXml.Attributes["id"].Value.ToString();
xnl=tileXml.SelectNodes("child::properties");
foreach(XmlNode jProp in xnl)
{
XmlNodeList subnodes=jProp.SelectNodes("child::property");
foreach(XmlNode pNode in subnodes)
{
tile.Properties.Add(new Property(pNode));
}
}
ts.Tiles.Add(tile);
}
//Tilebildl laden
if(loadTilesets)
{
try
{
ts.img=pooledLoader.FromFile(imgsourceComplete);
}
catch(FileNotFoundException ex)
{
throw new TilesetNotExistsException(ex.Message);
}
}
//Attrribute
ts.name=j.Attributes["name"].Value;
ts.firstgid=Convert.ToInt32(j.Attributes["firstgid"].Value);
ts.tilewidth=Convert.ToInt32(j.Attributes["tilewidth"].Value);
ts.tileheight=Convert.ToInt32(j.Attributes["tileheight"].Value);
Tilesets.Add(ts);
}
#endregion
#region Layers ermitteln
xnl=FileData.Document.SelectNodes("/map/layer");
foreach(XmlNode j in xnl) //pro layer
{
//Layer
LayerData lr=new LayerData();
//Attribute
lr.name=j.Attributes["name"].Value;
lr.width=Convert.ToInt32(j.Attributes["width"].Value);
lr.height=Convert.ToInt32(j.Attributes["height"].Value);
//Layerdaten
// Attribute werden als "<data encoding="base64" compression="gzip">" angenommen
string encoding=j["data"].Attributes["encoding"].Value;
string compression="uncompressed";
if(j["data"].Attributes["compression"]!=null)
{
compression=j["data"].Attributes["compression"].Value;
}
if(encoding!="base64")
{
throw (new NotImplementedException("Weitere Codierungsarten sind noch nicht implementiert!"));
}
if(compression!="uncompressed"&&compression!="gzip")
{
throw (new NotSupportedCompressionException("Weitere Kompressionsverfahren sind noch nicht implementiert!"));
}
//Base64 Encodierung
string layerdataBase64Compressed=j.SelectNodes("child::data")[0].InnerText;
layerdataBase64Compressed=layerdataBase64Compressed.TrimStart('\n');
layerdataBase64Compressed=layerdataBase64Compressed.Trim();
byte[] layerdataCompressed=CSCL.Crypto.Encoding.Base64.Decode(layerdataBase64Compressed);
//Gzip Decodierung (wenn nötig)
byte[] layerdataDecompressed;
if(compression=="uncompressed")
{
layerdataDecompressed=layerdataCompressed;
}
else
{
layerdataDecompressed=gzip.Decompress(layerdataCompressed);
}
//Interpretieren der Codierten Daten
lr.data=new int[lr.width, lr.height];
//int[,] zelle=new int[4, 3];
BinaryReader br=new BinaryReader(new MemoryStream(layerdataDecompressed));
for(int y=0;y<lr.height;y++)
{
for(int x=0;x<lr.width;x++)
{
lr.data[x, y]=br.ReadInt32();
}
}
Layers.Add(lr);
}
#endregion
#region Objektlayer ermitteln
xnl=FileData.Document.SelectNodes("/map/objectgroup");
foreach(XmlNode j in xnl) //pro layer
{
ObjectLayers.Add(new Objectgroup(j));
}
#endregion
}
static void Main(string[] args)
{
#region Init
if(args.Length!=1)
{
Console.WriteLine("Argument fehlt:");
Console.WriteLine("z.B. mono autoupdate.exe autoupdate.xml");
return;
}
if(!FileSystem.ExistsFile(args[0]))
{
Console.WriteLine("Angegebene Datei existiert nicht.");
return;
}
XmlData config;
try
{
config=new XmlData(args[0]);
}
catch(Exception e)
{
Console.WriteLine("Konfiguration konnte nicht gelesen werden.");
Console.WriteLine(e.ToString());
return;
}
Console.WriteLine("Autoupdate 1.2.1 wurde gestartet...");
string workfolder_original=Directory.GetCurrentDirectory();
string misc_servername=config.GetElementAsString("xml.misc.servername");
string ftp_data_server=config.GetElementAsString("xml.ftp.data.server");
string ftp_data_user=config.GetElementAsString("xml.ftp.data.user");
string ftp_data_password=config.GetElementAsString("xml.ftp.data.password");
bool irc_active=false;
string irc_network="";
string irc_channel="";
if(config.GetElementAsString("xml.irc.active")!="")
{
irc_active=Convert.ToBoolean(config.GetElementAsString("xml.irc.active"));
irc_network=config.GetElementAsString("xml.irc.network");
irc_channel=config.GetElementAsString("xml.irc.channel");
}
string ftp_update_server=config.GetElementAsString("xml.ftp.update.server");
string ftp_update_user=config.GetElementAsString("xml.ftp.update.user");
string ftp_update_password=config.GetElementAsString("xml.ftp.update.password");
bool activate_data=Convert.ToBoolean(config.GetElementAsString("xml.activate.data"));
bool activate_update=Convert.ToBoolean(config.GetElementAsString("xml.activate.update"));
string path_temp_folder=FileSystem.GetPathWithPathDelimiter(config.GetElementAsString("xml.path.temp"));
string path_repostiory_trunk=FileSystem.GetPathWithPathDelimiter(config.GetElementAsString("xml.path.repository.trunk"));
string path_repostiory_server=path_repostiory_trunk+"server/";
string path_repostiory_data=path_repostiory_trunk+"data/";
string path_repostiory_data_scripts=path_repostiory_data+"/scripts/";
string path_repostiory_data_maps=path_repostiory_data+"/maps/";
string path_server_root=FileSystem.GetPathWithPathDelimiter(config.GetElementAsString("xml.path.server.root"));
string path_server_data=path_server_root+"data/";
string path_server_data_scripts=path_server_data+"scripts/";
string path_server_data_maps=path_server_data+"maps/";
string path_server_start_script=path_server_root+"start-server.sh";
string path_server_stop_script=path_server_root+"stop-server.sh";
List<string> ExcludesDirsClient=new List<string>();
ExcludesDirsClient.Add("maps_templates");
ExcludesDirsClient.Add("maps_rules");
ExcludesDirsClient.Add("scripts");
ExcludesDirsClient.Add(".git");
List<string> ExcludesDirsServer=new List<string>();
ExcludesDirsServer.Add("maps_templates");
ExcludesDirsServer.Add("maps_rules");
ExcludesDirsServer.Add("graphics");
ExcludesDirsServer.Add("music");
ExcludesDirsServer.Add("sfx");
ExcludesDirsServer.Add(".git");
List<string> ExcludeFiles=new List<string>();
ExcludeFiles.Add("CMakeLists.txt");
#endregion
#region IRC Message absetzen
if(irc_active)
{
Console.WriteLine("Sende IRC Nachricht...");
irc.SendDelay=200;
irc.AutoRetry=true;
irc.ActiveChannelSyncing=true;
string[] serverlist=new string[] { irc_network };
int port=6667;
irc.Connect(serverlist, port);
irc.Login("Autoupdate", "Autoupdate", 0, "AutoupdateIRC");
irc.RfcJoin("#invertika");
Random rnd=new Random();
string funkyWord=FunkyWords[rnd.Next(FunkyWords.Length)];
irc.SendMessage(SendType.Message, irc_channel, String.Format("Autoupdate wurde auf dem Server {0} gestartet. {1}", misc_servername, funkyWord));
new Thread(new ThreadStart(StartIRCListen)).Start();
}
#endregion
#region Repository updaten
Console.WriteLine("Update Repository...");
Directory.SetCurrentDirectory(path_repostiory_data);
ProcessHelpers.StartProcess("git", "pull", true);
#endregion
#region Server stoppen und Serverdaten löschen
Console.WriteLine("Stoppe Server...");
Directory.SetCurrentDirectory(path_server_root);
ProcessHelpers.StartProcess(path_server_stop_script, "", false);
Console.WriteLine("Lösche Serverdaten...");
if(FileSystem.ExistsDirectory(path_server_data))
{
FileSystem.RemoveDirectory(path_server_data, true, true);
}
Console.WriteLine("Lösche temporäres Verzeichnis...");
if(FileSystem.ExistsDirectory(path_temp_folder))
{
FileSystem.RemoveDirectory(path_temp_folder, true, true);
}
#endregion
#region Neue Serverdaten kopieren
Directory.SetCurrentDirectory(path_server_root);
Console.WriteLine("Kopiere neue Serverdaten...");
FileSystem.CreateDirectory(path_server_data_maps, true);
FileSystem.CopyDirectory(path_repostiory_data, path_server_data, true, ExcludesDirsServer, ExcludeFiles);
#endregion
#region Clientdaten
Console.WriteLine("Erzeuge Verzeichnis mit Clientdaten...");
string clientPath=path_temp_folder+"clientdata"+FileSystem.PathDelimiter;
FileSystem.CreateDirectory(clientPath, true);
FileSystem.CreateDirectory(clientPath+"data"+FileSystem.PathDelimiter, true);
FileSystem.CopyDirectory(path_repostiory_data, clientPath+"data"+FileSystem.PathDelimiter, true, ExcludesDirsClient);
List<string> clientDataFiles=FileSystem.GetFiles(clientPath, true);
#endregion
#region Clientdaten Update erzeugen und hochladen
if(activate_update)
{
Console.WriteLine("Erstelle Zip Datei für Update...");
clientPath=clientPath+"data"+FileSystem.PathDelimiter;
//Zip erstellen
string zipFilename=path_temp_folder+"update-"+Various.GetTimeID()+".zip";
ZipFile z=ZipFile.Create(zipFilename);
z.BeginUpdate();
int fivePercent=clientDataFiles.Count/20;
int countZipFiles=0;
foreach(string i in clientDataFiles)
{
countZipFiles++;
if(FileSystem.GetExtension(i).ToLower()=="ogg")
{
Console.WriteLine("Datei {0} aus dem Update ausgeschlossen.", FileSystem.GetFilename(i));
continue;
}
string rel=FileSystem.GetRelativePath(i, clientPath, true);
z.Add(i, rel);
if(countZipFiles%fivePercent==0)
{
Console.Write(".");
}
}
z.CommitUpdate();
z.Close();
//adler 32
ICSharpCode.SharpZipLib.Checksums.Adler32 adler=new ICSharpCode.SharpZipLib.Checksums.Adler32();
FileStream fs=new FileStream(zipFilename, FileMode.Open, FileAccess.Read);
BinaryReader br=new BinaryReader(fs);
byte[] textToHash=br.ReadBytes((int)fs.Length);
adler.Reset();
adler.Update(textToHash);
string adler32=String.Format("{0:x}", adler.Value);
//Ressources
string resFile=path_temp_folder+FileSystem.PathDelimiter+"resources2.txt";
StreamWriter sw=new StreamWriter(resFile);
sw.WriteLine("{0} {1}", FileSystem.GetFilename(zipFilename), adler32);
sw.Close();
//Newsfile
string newsFile=path_temp_folder+FileSystem.PathDelimiter+"news.txt";
sw=new StreamWriter(newsFile);
sw.WriteLine("##3 Serenity");
sw.WriteLine("##0");
sw.WriteLine("##0 Entwicklerserver des Invertika Projektes");
sw.WriteLine("##0 Automatisches Update wird nach jedem");
sw.WriteLine("##0 Commit im Repository vorgenommen.");
sw.WriteLine("##0");
sw.WriteLine("##0 Status: in Betrieb");
sw.WriteLine("##0 Autoupdate vom {0}, {1} Uhr.", DateTime.Now.ToShortDateString(), DateTime.Now.ToShortTimeString());
sw.WriteLine("##0");
sw.WriteLine("##2 Das Invertika Development Team");
sw.WriteLine("##0");
sw.Close();
//Upload
Console.WriteLine("Beginne FTP Upload der Update Dateien...");
FTPSClient Client=new FTPSClient();
NetworkCredential networkCredential=new NetworkCredential();
networkCredential.Domain=ftp_update_server;
networkCredential.UserName=ftp_update_user;
networkCredential.Password=ftp_update_password;
Console.WriteLine("Verbinde mich mit FTP {0} mittels des Nutzers {1}.", ftp_update_server, ftp_update_user);
Client.Connect(networkCredential.Domain, networkCredential, ESSLSupportMode.ClearText);
List<string> currentFTPFiles=Client.GetDirectoryFiles(""); //TODO muss getestet werden
Console.WriteLine("Lösche bestehende Updatedateien auf dem FTP Server...");
foreach(string i in currentFTPFiles)
{
if(i.IndexOf("update")!=-1)
{
Client.DeleteFile(i);
}
}
Console.WriteLine("Lade Updatedatei hoch...");
Client.PutFile(zipFilename, FileSystem.GetFilename(zipFilename));
Client.PutFile(resFile, FileSystem.GetFilename(resFile));
Client.PutFile(newsFile, FileSystem.GetFilename(newsFile));
Client.Close();
}
#endregion
#region Server wieder starten
Console.WriteLine("Starte Server neu...");
Directory.SetCurrentDirectory(path_server_root);
ProcessHelpers.StartProcess(path_server_start_script, "", false);
#endregion
#region Clientdaten Data erzeugen und hochladen
if(activate_data)
{
//Upload
Console.WriteLine("Beginne FTP Upload der Data Dateien...");
FTPSClient ClientData=new FTPSClient();
NetworkCredential networkCredential=new NetworkCredential();
networkCredential.Domain=ftp_data_server;
networkCredential.UserName=ftp_data_user;
networkCredential.Password=ftp_data_password;
Console.WriteLine("Verbinde mich mit FTP {0} mittels des Nutzers {1}.", ftp_data_server, ftp_data_user);
ClientData.Connect(networkCredential.Domain, networkCredential, ESSLSupportMode.ClearText);
Console.WriteLine("Lade Data Dateien hoch...");
foreach(string ftpfile in clientDataFiles)
{
string relativeName=FileSystem.GetRelativePath(ftpfile, clientPath);
string dirToCreate=FileSystem.GetPath(relativeName, true);
if(dirToCreate!="")
{
string[] folders=dirToCreate.Split(FileSystem.PathDelimiter);
string dirTemp="";
foreach(string i in folders)
{
if(i.Trim()=="") continue;
if(i=="/") continue;
dirTemp+=i+FileSystem.PathDelimiter;
try
{
ClientData.CreateDirectory(dirTemp);
}
catch
{
}
}
}
Console.WriteLine("Datei {0} wird hochgeladen...", relativeName);
ClientData.PutFile(ftpfile, relativeName);
}
ClientData.Close();
}
#endregion
#region IRC Message absetzen und aus Channel verschwinden
if(irc_active)
{
Console.WriteLine("Sende IRC Nachricht...");
irc.SendMessage(SendType.Message, irc_channel, String.Format("Autoupdate wurde auf dem Server {0} beendet und manaserv wieder gestartet.", misc_servername));
Thread.Sleep(15000);
irc.Disconnect();
}
#endregion
#region Ende
Console.WriteLine("Autoupdate beenden");
#endregion
}
public static void Main(string[] args)
{
//Options
if(!FileSystem.ExistsFile("config.xml"))
{
Console.WriteLine("No config.xml file found.");
return;
}
XmlData Options=new XmlData("config.xml");
recieverMail=Options.GetElementAsString("xml.SMTP.RecieverMail");
smtpserver=Options.GetElementAsString("xml.SMTP.Server");
senderMail=Options.GetElementAsString("xml.SMTP.SenderMail");
smtpUsername=Options.GetElementAsString("xml.SMTP.Username");
smtpPassword=Options.GetElementAsString("xml.SMTP.Password");
//Files
Dictionary<string, string> commandLine=CommandLineHelpers.GetCommandLine(args);
List<string> files=new List<string>();
bool convert=commandLine.ContainsKey("convert");
bool merge=commandLine.ContainsKey("merge");
List<string> clFiles=CommandLineHelpers.GetFilesFromCommandline(commandLine);
foreach(string clFile in clFiles)
{
if(FileSystem.IsFile(clFile))
{
files.Add(clFile);
}
else
{
files.AddRange(FileSystem.GetFiles(clFile, true));
}
}
if(files.Count==0)
{
Console.WriteLine("No files specified.");
return;
}
if(merge)
{
string name=FileSystem.GetValidFilename(files[0]) + " (merged).html";
StreamWriter writer=new StreamWriter(name);
writer.WriteLine("<html>");
writer.WriteLine("<head>");
writer.WriteLine("</head>");
writer.WriteLine("<body>");
foreach(string file in files)
{
string[] lines=File.ReadAllLines(file);
if(FileSystem.GetExtension(file)=="txt") //Txt aufbereiten
{
foreach(string line in lines)
{
writer.WriteLine("{0}<br/>", line);
}
}
else
{
foreach(string line in lines)
{
writer.WriteLine(line);
}
}
}
writer.WriteLine("</body>");
writer.WriteLine("</html>");
writer.Close();
files.Clear();
files.Add(name);
}
//Send Files
foreach(string file in files)
{
string fileSend=file;
//Preconvert
if(FileSystem.GetExtension(fileSend)=="txt") //Txt aufbereiten
{
string htmlFile=FileSystem.GetPath(file)+FileSystem.GetFilenameWithoutExt(file)+".html";
ConvertTextFile(file, htmlFile);
fileSend=htmlFile;
}
//Sending
string subject="";
if(convert)
{
subject="convert";
}
Console.WriteLine("Send file {0}...", FileSystem.GetFilename(file));
SMTP.SendMailMessageWithAuthAndAttachment(smtpserver, smtpUsername, smtpPassword, senderMail, "kindleuploader", recieverMail, recieverMail, subject, "", fileSend);
//FileSystem.RemoveFile(htmlFile);
}
}
public Observer(string configFile)
{
//Config auslesen
XmlData Options=new XmlData(configFile);
recieverMail=Options.GetElementAsString("xml.SMTP.RecieverMail");
smtpserver=Options.GetElementAsString("xml.SMTP.Server");
senderMail=Options.GetElementAsString("xml.SMTP.SenderMail");
smtpUsername=Options.GetElementAsString("xml.SMTP.Username");
smtpPassword=Options.GetElementAsString("xml.SMTP.Password");
username=Options.GetElementAsString("xml.IRC.UserName");
realname=Options.GetElementAsString("xml.IRC.RealName");
ident=Options.GetElementAsString("xml.IRC.Ident");
server=Options.GetElementAsString("xml.IRC.Server");
channel=Options.GetElementAsString("xml.IRC.Channel");
//Timer verbinden
Timer.Interval=5000;
Timer.Elapsed+=new ElapsedEventHandler(timer_Tick);
Timer.Enabled=true;
//IRC Setup
irc.SendDelay=200;
irc.AutoRetry=true;
irc.ActiveChannelSyncing=true;
irc.OnChannelMessage+=new IrcEventHandler(OnChannelMessage);
irc.AutoRejoin=true;
irc.AutoRejoinOnKick=true;
irc.AutoRelogin=true;
irc.AutoRetry=true;
string[] serverlist;
serverlist=new string[] { server };
int port=6667;
Task.Factory.StartNew( () => {
while(true)
{
try
{
irc.Connect(serverlist, port);
irc.Login(username, realname, 0, ident);
irc.RfcJoin(channel);
Console.WriteLine("Connected to "+server+" -> "+channel);
irc.Listen();
irc.Disconnect();
}
catch(ConnectionException ex)
{
string msg="Couldn't connect! Reason: "+ex.Message;
Conversion.Add(msg);
Console.WriteLine(msg);
}
catch(Exception ex)
{
string msg="Another exception: "+ex.Message;
Conversion.Add(msg);
Console.WriteLine(msg);
}
Thread.Sleep(75000);
}
});
}
