I was paying for a VPN. Then my provider changed its terms suddenly, and customer support was no help in dealing with it. I looked at other providers and did not find one I was satisfied with either.

What I needed was modest. Some sites in Ukraine and Germany only work properly from inside those countries, and I am not always inside them. I did not need thousands of servers or a smart app. I needed a tunnel that answered to me, on terms that could not change overnight.

So on 28 May 2026 I made the first commit to just-another-vpn-server.

Why speak OpenVPN

The easy way to make a VPN is to invent a small private protocol. Then you also own every client, on every device, forever.

Speaking the OpenVPN wire protocol avoids that. A stock openvpn client, Tunnelblick and OpenVPN Connect already exist, and none of them should need to know that the other end is a few thousand lines of Rust. It also gives the project an unforgiving definition of done: either an unmodified client connects, or it does not.

"Written from the wire format up" means the protocol, not the cryptography. Packet framing, the reliability layer, the key exchange, sessions and rekeying are in this codebase. TLS comes from rustls, and the ciphers come from established crates. I wanted a VPN server, not my own crypto.

The first week

The first commit was already large: 31 files and about 6,900 lines, including a Docker harness that tests against a real OpenVPN client. Claude is credited as co-author on 19 of the 29 commits, including the fixes below. The hard part started when real clients on real machines connected to it.

Linux went first. Writes to the TUN device failed with EINVAL, and the cause turned out to be two separate things. The packet-information header behaved unreliably across versions of the tun crate, so the server now handles those four bytes explicitly. And OpenVPN Connect sends internal messages over the data channel that are not IP packets at all. Writing one to the TUN device failed and killed the writer task, so they are now dropped before that point.

Then something less dramatic: every restart added its iptables rules again, without removing the old ones. Nothing broke at first. There were just more and more duplicates.

The day macOS said no

Full-tunnel mode on macOS took a whole day and is my favourite part of the history. On 4 June:

1. redirect-gateway def1 seemed to send traffic the wrong way, because the client added a bypass route for the gateway through the physical interface. So I replaced it with explicit /1 routes.
2. That was not enough, so I switched to point-to-point style addressing.
3. That was not it either, and the third attempt of the day went back to the standard subnet format.

The real failure was a chain. An explicit pushed subnet route triggered Tunnelblick's loop protection, which made routing setup fail and retry for over a minute. Meanwhile the server saw no traffic, reached its idle timeout and evicted the session. The client then kept sending packets with a peer_id that no longer existed.

So the fix was mostly to stop being clever: send what a normal OpenVPN server sends, stop pushing that extra route, and give the idle timeout more headroom. When your job is to be compatible, the standard behaviour is usually standard for a reason.

What it is now

Version 0.1.8 does what I set out to build, and a bit more:

• UDP and TCP transport, with mutual TLS on the control channel
• AES-256-GCM on the data channel, with a replay window
• tls-auth and tls-crypt
• Rekeying from either side without dropping packets
• Address pools, IPv6 in the tunnel, NAT and per-client settings

OpenVPN has no standards body behind it, so compatibility here means working with the real thing. It is verified end to end against OpenVPN 2.6.14, and there is a script for overnight stability runs. The repository has CI, a dependency security audit and release builds. The audit has already earned its place: the latest commits update a TLS dependency to fix published security advisories.

It also has limits, and the README lists them:

• It has not been security-audited.
• Authentication is by client certificate only.
• AES-256-GCM is the only data-channel cipher.
• NAT and IPv6 in the tunnel are Linux-only.

It suits self-hosting and learning. It is not a hardened replacement for the OpenVPN daemon, and I would not suggest anyone treat it as one.

Using it

This is the part that makes me happiest. When I am abroad, I connect with an ordinary OpenVPN client and reach the location-limited sites in Ukraine and Germany I built it for, through a server I run myself.

No provider can change the terms on me now. The trade-off is that I have also become customer support, and that department only answers when it feels like it. At least I know who to complain to.

The code is on GitHub, under the MIT licence.

So my rule for this lab was that a block counts only if the same attempt succeeds once the layer blocking it is removed.

The setup

The lab is one RKE2 node in a VM on a NUC, on an isolated network. It installs from an offline bundle, pulls only from a read-only internal registry, and admits only images signed with the bundle's key. Two independent layers stop traffic leaving:

• In the cluster: a default-deny network policy that also covers new namespaces.
• At the VM: a black-hole default route, plus a host firewall.

The test

A Go program on the host opens and closes each layer, then tries to reach a canary listener from a pod. The canary lives on temporary host addresses, so opening the VM path never opens a route to the internet.

                  policy on    policy off
VM path closed    blocked      blocked
VM path open      blocked      REACHED

Only the bottom-right cell connects, and the canary's own log has to confirm it. That one cell shows the other three were blocked by the layers, not by a broken test.

make rebuild destroys the VM, rebuilds it and runs everything: 185 checks. It took 225 seconds to build and 572 seconds to test, with downloads cached.

What the controls caught

A control that did nothing. To show that cluster DNS can't leak a name, the test temporarily adds a forwarder to CoreDNS and expects a random label to reach the canary. Nothing arrived. The Corefile said cache 30 with two spaces, so my edit never matched and no forwarder was added. Without the control, the result would have read as "zero leaks".

A check that accepted a crash loop. An older test checked for the Running phase, which a crash-looping pod still reports. Its probe pod was in fact exiting on a bad argument. It now has to be ready.

A cost I hadn't planned for. With the registry down, running pods carry on and containers restart from cache, but new pods are refused, even signed ones, because the verifier needs the registry to check the signature. That fails closed, and a pod rescheduled during an outage won't start.

What this doesn't prove

• The canary is on the host, not a remote network.
• Public IP and IPv6 targets are blocked, but have no open-path control, because the test never opens the internet.
• The gateway address stayed unreachable even with the policy off, so its block isn't shown to come from the policy.
• Only TCP and DNS over UDP were tested, not ICMP.
• It is one node in a lab, designed for air-gapped environments and not certified for anything.

Next comes what runs inside the gap: retrieval, then a gateway for AI that can act on real systems only after a person confirms.

I picked axolotls because they are absurd. A salamander that never grows up, with feathery pink gills and a permanent smile — if you are going to spend evenings staring at a creature model, it may as well be that one.

Twenty commits later, over five weeks, the answer turned out to be yes, with a caveat I will get to.

What it became

An endless procedurally generated underwater maze. Seaweed, kelp, coral, mossy rock rooms on a seabed, and a cast of creatures wandering through it — whale, shark, seal, lamprey, octavia the octopus, blobfish, narwhal, and of course the axolotl. Each one announces its own name when you meet it, in whichever of 76 languages you are playing in.

Every so often — four percent of eligible rooms — you swim into something that was placed rather than generated:

• A shipwreck: a beached hull with masts and rigging, crewed by zombie pirates and a zombie parrot, with its own sea shanty that fades in as you approach and periodically breaks into a spoken chorus of Fifteen Men on a Dead Man's Chest.
• A sunken temple: weathered pillars, one fully collapsed, around a robed figure in a praying posture, with a wordless choir drone.
• A sunken playground: swing set, slide, seesaw, and a roundabout that actually spins and carries you with it — the one piece in the game with real moving-platform physics. Beside it a small brick fortress with four walled turrets, deliberately left open at the top so that swimming up and over is the only way in. A music-box Frère Jacques drifts in as you get close.

My children found the playground first. Then the fortress. Then they worked out that you can get the roundabout going fast enough to be thrown off it, which was not a feature I had planned and which I have left in.

The caveat

The honest version of "AI built a 3D game" is that the assistant was extraordinarily good at the parts with known shapes and needed steering on the parts that were actually decisions.

Three examples from the commit log, which is unusually candid: big rework on 13 September, and then ui fixes six times across the following week.

The fortress windows. The collision system only understands axis-aligned boxes. A window is a hole, and a hole in a box is not a box. The obvious implementation — one solid wall with a dark rectangle painted on it — looks right in a screenshot and wrong the moment a child swims at it. Each wall is built from four separate pieces, two pillars, a lintel and a sill, framing a real gap. Nobody asks for that. You only discover it is necessary by watching someone try to swim through a picture of a window.

The temple figure. A robed praying figure is trivially easy to make accidentally specific to one religion. The version in the game is a deliberately universal orans posture with a fully shadowed, featureless hood. That is not a technical problem and no amount of model capability would have raised it; it is a judgement about what you are willing to ship to strangers' children.

The music. Everything audible in the game is either synthesised or public domain — a shanty from Treasure Island, an 18th-century French folk round. Checking that is tedious, unglamorous, and entirely on the human.

So: the assistant wrote a very large share of 28 modules of game code, fast, and the parts I had to own were the taste and the liability. That split has held for me across every project this year, and I find it more reassuring than the alternative would be.

Multiplayer, in one day

The most interesting engineering is dated 9 October — four commits, all in one go: multiplayer to web and, multiplayer to web, more fixes, more fixed.

Adding multiplayer to a procedural world normally means a second implementation. The server has to know where every creature is, which means reimplementing the maze generator, the colliders, the spawn tables and the creature AI on the server, in whatever language the server is written in — and then keeping four copies of that logic in step forever.

Instead, the simulation lives in a module that imports no rendering code and no DOM. The browser runs it. The Node server imports the exact same file and runs it too. There is one description of how a creature wanders, and both ends execute it. Deploying the server means shipping two directories.

Identity is a SHA-256 proof-of-work solved in a worker thread while the connecting spinner turns. No email, no password, nothing to type. Nicknames are assigned by the server from a word list, and there is no free text anywhere in the game — which means there is no moderation surface at all. When your users include your own children and their friends, the cheapest way to handle a hard problem is to design it out of existence.

Was the experiment a success?

It was supposed to answer a question about tooling and it ended up answering a different one.

The assistant comfortably handled things I would have budgeted weeks for: procedural generation, collision, creature behaviour, a whole audio layer, 76 locales, a Capacitor build for iOS and Android. That is genuinely new, and anyone telling you otherwise has not tried recently.

But the game is good — to the extent it is good — because of a roundabout that spins you off it, a fortress you have to swim over to enter, and a parrot that is also a zombie. None of those came out of a prompt. They came out of watching my children play, and going back in.

5001 Axolotls runs in a browser at turevskiy.com/5001axolotls, and is free on the App Store and Google Play.

It began on 30 September 2025, with three commits in one evening — Initial Commit, initial version, initial version again. I was learning Spanish. The method I had settled on was five minutes at a time, several times a day: short enough that you never negotiate with yourself about starting, frequent enough to stick. What that needs is a timer you can begin in one tap and then forget.

Every timer I tried wanted more from me than that. An account, a streak, cloud sync, a weekly report, a subscription. I wanted a button.

So: one button, five minutes, a sound at the end.

This was four months before I started 5001 Words. The same stretch of trying to learn a language produced both, the timer first.

A week of making it look right

The commit log for early October 2025 is almost entirely interface: ui cleanup, ipad ui fixes, UI improvements, best ui, BIG refactoring, moving stuff around, uodated ui. For an app with one button.

That ratio was correct. When the whole product is a button, the button is the product.

Then, on 9 October, two commits that matter more than they look: downgrade to ios16, and immediately after, downgrade to ios 15+, with extended functionality available on ios 16+.

I had built against the current SDK, as you do, and then went and looked at who that excluded. Dropping to iOS 15 meant giving up APIs I had already used and writing the graceful-degradation paths to keep the newer features where they were available. It is unglamorous work that no user will ever notice, and it is the difference between an app for people with new phones and an app for people with phones.

Then nothing for almost a year.

The rename

The app worked. I used it daily. There was nothing I wanted from it, so I did not touch it — the same dormancy that 5001 Words went through, only longer.

What broke the silence was Android. On 3 September 2026: preparing for publishing to Android store. And while porting, I had to confront what the thing had actually become.

Somewhere in that year I had stopped using it for Spanish and started using it at my desk. Twenty-five minutes, a break, repeat. I had been running a Pomodoro timer for months without renaming it in my head, because a Pomodoro timer is an interval timer with different numbers and a convention attached.

On 19 September 2026, one commit: "Rename to 5001 Tomatoes: new icon, translations, screenshots, and 1.3.0 release prep."

Pomodoro is Italian for tomato; the technique is named after a kitchen timer shaped like one. The name acknowledged what the app had become and brought it into the same family as the vocabulary app. The engine did not change at all — only the numbers it defaults to, an auto-continue setting for the work-break-work cycle, and statistics so it can answer "did I actually do this today".

The directory name never caught up. I have left it alone, because it is an accurate record of what I set out to build.

Pomodoro, and everything you can change

The Pomodoro technique comes from Francesco Cirillo, who timed his study sessions in the late 1980s with a tomato-shaped kitchen timer. The classic recipe is 25 minutes of work and a 5-minute break, with a longer break after every four rounds. Its value is the same as my five minutes: you commit to a short block rather than to finishing the task.

The one button is now two. Simple runs a single interval, which is the original app. Pomodoro runs the work-and-break cycle. Above them sit today's count, the minutes it adds up to, and progress towards a daily goal.

A recipe is only a starting point, so all of its numbers can be changed:

• Timer duration: the length of a Simple interval, 5 minutes by default. The Android listing gives the range as 1 to 60 minutes.
• Work, short break, long break: set separately, starting from 25, 5 and 15 minutes.
• Continue automatically: off by default. Off, each break waits for you to tap Continue. On, the cycle runs by itself.
• Pause and resume: the button can be hidden, if you would rather not have the option.
• Daily goal: 8 intervals by default, which drives the "0 of 8 today" line on the home screen.
• Language and appearance: the language follows the device unless you choose another, and the background can be your own photo.

Settings save as you change them, and you can open them while a timer is running or paused. That means no save button and no need to stop a session to fix a number.

The running screen stays deliberately plain: a dial, the time left, and two buttons. On Android, an ongoing notification lets you pause, resume or stop without opening the app. A separate statistics screen shows your history as daily bar charts.

The app is also not only for Pomodoro. Five minutes of Spanish was its first job, and its store listings also suggest study sessions, exercise sets and meditation, because a timer does not care what you are counting.

What it deliberately does not do

No account. No cloud. No ads. No in-app purchase. No analytics.

Everything lives on the device in the platform's own small-settings store — SharedPreferences on Android, its equivalent on iOS. There is no database, no dependency-injection framework, no sync layer, because a timer that counts to twenty-five needs none of them, and each would be a thing to maintain and a place for data to leak.

That is the stance across all my apps, and it is easier to hold than it sounds: most features that require collecting data are features I did not want.

The one genuinely hard part

A timer is trivial until you remember that the operating system does not care about you.

Backgrounded, suspended, killed to reclaim memory — in any of those states an in-process countdown stops existing, and the user is standing in the kitchen waiting for a sound that will never come. A timer that silently fails is worse than no timer, because it accepted a promise and then dropped it.

So the countdown is not the authority. The alarm is registered with the system's own alarm service, which outlives the app being killed, with a notification and completion feedback behind it. The in-app state machine is what you watch; the OS-level alarm is what actually fires. Getting those two to agree across every lifecycle state was most of the real work.

The pleasant things came after that foundation was right: Live Activities, home-screen, lock-screen and StandBy widgets, haptics, and a native Watch app.

Seventy-six languages for four words

The Android build ships in 76 locales, iOS in rather more. For an app whose entire vocabulary is roughly start, pause, reset and settings, that is close to absurd.

It is also nearly free. The translations are not maintained twice — a script converts the iOS .strings files into Android's strings.xml, so a wording change made once propagates and the platforms cannot drift. Same discipline as the vocabulary app, which has the same problem at much larger scale.

Why bother for four words? Because the cost is a script, and an app that greets someone in their own language has already said something about who it was built for.

Not everything needs to grow

One of these projects became a vocabulary platform across 84 languages. The other found its shape in the first week of October 2025 and has spent the time since getting quieter — fewer taps, more reliable alarms, better behaviour when the OS is hostile, and a wider range of phones it will run on at all.

I think the second outcome is underrated. There is no roadmap. It does the thing.

5001 Tomatoes is free, with no ads and no purchases, on the App Store and Google Play.

So I wrote my own. One deck, Spanish to English, on an iPhone.

Then nothing for four and a half months.

That gap is the part I would skip if I were selling this, and it is the part that matters. The app worked. I used it. I did not touch the code because there was nothing I wanted from it. Most side projects die there, and that is usually correct — the itch is scratched and the tool is done.

Audio, and then the second language

On 24 June I committed media and content. Reading a word is not learning a word; I wanted to hear it. Microsoft's edge-tts gives you neural voices for most major languages at no cost and with no licensing problem, so the deck gained pronunciation on both sides of the card.

Later the same day: second language. Then dutch sounds, dutch audio. Once audio existed, adding a language was mostly data, and the thing stopped being a Spanish app.

The plane

The next day I committed downloadable audio packages.

I had been on a flight, opened the app, and found it useless. The word lists were local but the audio was not, and a vocabulary app that cannot speak on a plane is a vocabulary app that cannot be used in exactly the dead time it was built for.

The fix is a single .pack file per language — word list plus every audio clip, between 55 and 280 MB depending on the language. The detail I am still pleased with is that the word list sits at the front of the file and is fetched with a range request, so you can start studying a few seconds after tapping download while the audio continues in the background. You do not wait for 200 MB to learn your first word.

A language a day

Then it ran away from me. Still 25 June: german, jiddish package, more languages, french, ukrainian. Nineteen commits that month, twenty-four in July, twenty-five in August.

Along the way the app grew an Apple Watch build with the full feature set, a home-screen widget, notifications, auto-play that speaks cards on a timer so you can study without hands, bidirectional decks with separate audio per direction, and a focus mode that drills a subset of what you have not learned. On 19 August: android initial version.

None of that was planned. Each piece existed because I wanted it on a particular day.

Pflege, Kita, Handwerk

The turn that made this more than a toy came from reading about people learning German for work.

Not German. German for work — and specifically the vocabulary of care homes, of childcare, of the trades. A nurse arriving from Romania does not need the subjunctive before she needs the word for a pressure sore. The general-purpose courses serve her badly, and the specialised material is thin and expensive.

So the app grew vocational tracks: Pflege (care), Kita (childcare), Handwerk (trades). Each paired with the languages the people doing those jobs actually arrive speaking — Arabic, Bulgarian, Polish, Romanian, Turkish, Ukrainian.

That pairing is the whole point. !A language page: the general deck first, then decks for specific jobs. This one is Italian.

German–English vocational decks already exist. German–Bulgarian care vocabulary, with audio, offline, free, on a phone — that is a gap, and it is a gap precisely because the people in it are not a lucrative market.

The language Google will translate but not speak

Yiddish broke the pattern.

Every other language in the app gets its audio from edge-tts, with espeak-ng filling in for Latin, Basque and Scottish Gaelic where no neural voice exists. For Yiddish there was nothing. Google Translate handles the text. It will not speak it. No major provider offers a Yiddish voice, because there is no commercial case for one.

A language written down since the thirteenth century, and you cannot make a computer say a word of it.

So I built the text-to-speech myself, wrapping pretrained FastSpeech2 checkpoints into something that takes Yiddish text and returns audio, then generating the deck's clips in batch. It is now a separate project, and the Yiddish deck ships bundled with the app rather than as a download.

This is the part of the whole story I would defend hardest. The app has 294 decks across 84 languages, and the ones that justify its existence are not the ones with the largest speaker counts.

Where the limit actually is

Nine months on, the constraint is not code and it is not my time. It is whether a language has a usable text-to-speech voice and a translation source good enough to trust.

Where both exist, a new deck is close to free. Where neither exists, as with Yiddish, it costs a side project of its own. That is a strange and rather cheering place to end up: the bottleneck on teaching a language is no longer software, it is whether anyone has bothered to build a voice for it.

On the machine that helped

I built nearly all of this alongside Claude, and I spent a fair amount of the time deliberately trying to find the edge of what it could do — the Watch target, the pack format, batching a TTS model I had just assembled, localising an interface into dozens of languages I do not read.

It kept up. That is not a small thing to say about nine months of work across two platforms, and it is also not the interesting part. The interesting part is that the decisions that made this app worth using — offline because of one flight, vocational German because of one article, Yiddish because nobody else would — were not technical decisions at all. The machine was very good at the half of the work that was.

5001 Words is free on the App Store and Google Play. The vocational decks have their own pages: Pflege, Kita, Handwerk.

Meanwhile the same server was hosting three apps I had actually shipped — a vocabulary trainer, a focus timer, a multiplayer game that runs in the browser — and the homepage linked to none of them. Someone landing on the site had no way to know any of it existed. That is the kind of thing you stop seeing after the hundredth visit to your own domain.

So I rebuilt it. These are the decisions worth writing down.

The CV was eleven months stale

cv/resume.pdf was dated 5 June. The version I would actually send someone was on my laptop. That gap is embarrassing in a specific way: anyone who found the site through search got an out-of-date picture of me while I was busy sending the current one by email.

The fix was boring — regenerate, upload, and point the old URL at the new file so existing bookmarks silently get the current version rather than a 404 or a stale download. The old copy is still on disk under a dated name. Nothing that was ever public should simply vanish.

Three languages, not four

The site now exists in English, German and Ukrainian. English is the default, German because I live and work in Germany, Ukrainian because it is my first language and because the audience is real.

I considered Hebrew — I have worked in Israel, and my CV lists it. I left it out, and the reason is not political. I rate myself a beginner in Hebrew, which means I could not proofread my own professional copy. Publishing text you cannot check is worse than not publishing it. If I target Israeli employers later, I will add it with a native speaker reading it first.

Each language gets its own path, hreflang annotations, and a switcher that does not open new tabs. Everything else on the page does, so that clicking a project does not cost you the page you were reading.

Analytics without a cookie banner

I wanted to know whether anyone reads this, and specifically which language of my CV gets downloaded. The reflex is to drop in a JavaScript tracker.

I used nginx's own access logs instead, with GoAccess generating a static report hourly. No JavaScript, no cookies, no consent banner, nothing to block — and, critically, it counts PDF downloads, which a client-side tracker cannot see at all. The file never executes any of my code; the request simply lands in a log.

Two things went wrong immediately, both instructive. First, every site on the box shared one access log, and the combined log format carries no host field — so the numbers mixed five unrelated domains together with no way to separate them. Second, of roughly 129,000 requests over nine days, 8,000 were an uptime monitor and another 24,000 were crawlers, plus a steady drizzle of probes for /wp-admin, /.env and /phpmyadmin that belongs to every public IP address.

Had I just read the headline number I would have believed my personal site gets 19,000 visits to its front page. It does not. Per-site logging and an explicit filter now, and the honest consequence is that my statistics start from today.

No chatbot

I build grounded assistants for a living. The obvious move is to put one on the site that answers questions about my CV.

I decided against it. A public language-model endpoint on a personal site is a bill and a prompt-injection surface, and this is the one page where my credibility has to be unimpeachable — the page where someone checks whether I am worth a conversation. The failure mode is not that it costs money. It is that somebody screenshots my own site saying something stupid.

There is a better version of the same instinct, which is to describe the work plainly in a section about it, including the part that actually matters: every figure the real assistant reports is computed server-side from role-scoped endpoints, never generated by the model, and every device action it offers passes through a confirmation step. In a supervised-autonomy fleet that boundary is not a caveat on the design. It is the design.

The bug

I made the project cards clickable by wrapping each one in an anchor. Inside each card were two more anchors, to the App Store and Google Play.

Nested anchors are invalid HTML. The browser does not error — it silently un-nests them, which pushed the store links out of their cards and into the grid as siblings. The layout collapsed into a row of empty boxes with orphaned buttons floating between them, and because I was reading the markup rather than the rendering, it took a screenshot to see it.

The fix is the standard stretched-link pattern: the card is an <article>, the title holds the only real link, and a pseudo-element on it covers the whole card. Sibling links sit above that with z-index, so they keep working. One container, one primary target, no nesting.

Written with a machine, by me

I used an AI assistant throughout — drafting copy, generating three language variants, writing the build scripts, and reviewing the rendered output.

I am not labelling the pages as AI-made. Nobody credits their editor or their compiler, and on a page whose entire job is credibility, a badge like that invites the question of what else was generated: the claims, the commit counts, the years. Every number on the site is checkable, and that is the thing I want load-bearing.

What I will say, because it is the actual skill, is that the judgment about what to hand over and what to read line by line is the whole job now. The machine wrote the nested anchors. It also caught them, and then fixed them properly rather than hacking around the symptom. Both of those are worth knowing about.

After spending couple of hours understanding why my C++ - baked understanding of delete operator does not work in JavaScript I just another time understood that JavaScript is completely special language.

Here is a deep discussion of how it works:

http://perfectionkills.com/understanding-delete/

Tags:
JavaScript delete property delete variable

public class ReportsApiController : ApiController { [System.Web.Http.HttpGet] public HttpResponseMessage GetQueryResultByWebSocket() { HttpContext.Current.AcceptWebSocketRequest(new MyWebSocketHandler(this)); return Request.CreateResponse(HttpStatusCode.SwitchingProtocols); }

}

internal class MyWebSocketHandler : WebSocketHandler
{
private static WebSocketCollection _connectedClients;
private ApiController _controller;
static MyWebSocketHandler()
{
_connectedClients = new WebSocketCollection();
}
public MyWebSocketHandler(ApiController controller)
{
this._controller = controller;
}
public override void OnOpen()
{
base.OnOpen();
_connectedClients.Add(this);
}
public override void OnClose()
{
_connectedClients.Remove(this);
base.OnClose();
}
public override void OnMessage(string message)
{
HttpContext ctx = HttpContext.Current;
var currentCulture = System.Threading.Thread.CurrentThread.CurrentCulture;
var currentUICulture = System.Threading.Thread.CurrentThread.CurrentUICulture;
new Task(() =>
{
HttpContext.Current = ctx;
System.Threading.Thread.CurrentThread.CurrentCulture = currentCulture;
System.Threading.Thread.CurrentThread.CurrentUICulture = currentUICulture;
var request =
JsonConvert.DeserializeObject(message);
Debug.WriteLine("Received #{0} @{1} t:{2}", request.id, DateTime.Now,
Thread.CurrentThread.ManagedThreadId);
try
{
if (request.url == "/api/ReportsApi/GetQueryResult")
{
var data = MyQueriesModel.GetQueryResult(request.queryParams);
UmiWebSocketResponse result = new UmiWebSocketResponse
{
data = data,
error = null,
id = request.id,
timeStampSent = request.timeStampSent
};
Debug.WriteLine("Sent #{0} @{1} t:{2}", request.id, DateTime.Now,
Thread.CurrentThread.ManagedThreadId);
this.Send(JsonConvert.SerializeObject(result));
}
else if (request.url == "/api/ReportsApi/GetQueryObjResult")
{
var jss = new JavaScriptSerializer();
jss.MaxJsonLength = int.MaxValue;
var data = jss.Serialize(UmiQueriesModel.GetQueryObj(request.queryParams));
UmiWebSocketResponse result = new UmiWebSocketResponse
{
data = data,
error = null,
id = request.id,
timeStampSent = request.timeStampSent
};
Debug.WriteLine("Sent #{0} @{1} t:{2}", request.id, DateTime.Now,
Thread.CurrentThread.ManagedThreadId);
this.Send(JsonConvert.SerializeObject(result));
}
else if (request.url == "/api/ReportsApi/GetResource")
{
var jss = new JavaScriptSerializer();
jss.MaxJsonLength = int.MaxValue;
var prefix = "MyLibrary.Resources.Reports.";
try
{
var fullNames = request.queryParams.QueryName.Split(',');
var data = new Dictionary();
foreach (var fullName in fullNames)
{
int idx = fullName.LastIndexOf('.');
var typeName = fullName.Substring(0, idx);
var fullTypeName = typeName;
var resourceName = fullName.Substring(idx + 1);
if (!fullTypeName.StartsWith(prefix))
fullTypeName = prefix + fullTypeName;
try
{
var rm = new ResourceManager(fullTypeName, Assembly.GetExecutingAssembly());
data.Add(typeName + "." + resourceName, rm.GetString(resourceName));
}
catch (Exception ex)
{
Debug.WriteLine("Error performing resource request: {0}",
request.queryParams == null ? "null" : request.queryParams.QueryName);
data.Add(typeName + "." + resourceName, "");
}
}
UmiWebSocketResponse result = new UmiWebSocketResponse
{
data = jss.Serialize(data),
error = null,
id = request.id,
timeStampSent = request.timeStampSent
};
Debug.WriteLine("Sent #{0} @{1} t:{2}", request.id, DateTime.Now,
Thread.CurrentThread.ManagedThreadId);
this.Send(jss.Serialize(result));
}
catch (Exception ex)
{
Debug.WriteLine("Error performing resource request: {0}",
request.queryParams == null ? "null" : request.queryParams.QueryName);
UmiWebSocketResponse result = new UmiWebSocketResponse
{
data = "",
error = "Error performing resource request",
id = request.id,
timeStampSent = request.timeStampSent
};
Debug.WriteLine("Sent #{0} @{1} t:{2}", request.id, DateTime.Now,
Thread.CurrentThread.ManagedThreadId);
this.Send(jss.Serialize(result));
}
}
else
{
var routeToSearch = request.url.Replace("/PartialViews/", "");
var methods = Assembly.GetExecutingAssembly().GetTypes()
.Where(t => t.IsSubclassOf(typeof(PartialViewsController)))
.SelectMany(t => t.GetMethods())
.Where(m =>
{
if (m.Name == routeToSearch)
return true;
System.Web.Mvc.RouteAttribute attr =
m.GetCustomAttributes(typeof(System.Web.Mvc.RouteAttribute), false).FirstOrDefault() as System.Web.Mvc.RouteAttribute;
if (attr == null)
return false;
return attr.Template == routeToSearch;
})
.ToArray();
if (methods.Length > 0)
{
var controller = Activator.CreateInstance(methods[0].DeclaringType) as PartialViewsController;
string baseUrl = HttpContext.Current
.Request
.Url
.GetComponents(UriComponents.SchemeAndServer, UriFormat.SafeUnescaped);
var routeData = new RouteData();
routeData.Values.Add("controller", controller.GetType().Name.Replace("Controller", ""));
var controllerContext = new ControllerContext(
new HttpContextWrapper(
new HttpContext(
new HttpRequest(null, baseUrl + request.url, null),
new HttpResponse(null))),
routeData, controller);
controller.ControllerContext = controllerContext;
PartialViewResult pvr;
if (methods[0].GetParameters().Length == 2)
{
pvr = methods[0].Invoke(controller, new object[] { request.queryParams, Type.Missing }) as PartialViewResult;
}
else if (methods[0].GetParameters().Length == 1)
{
pvr = methods[0].Invoke(controller, new object[] { request.queryParams }) as PartialViewResult;
}
else
{
pvr = methods[0].Invoke(controller, new object[0]) as PartialViewResult;
}
var data = pvr == null ? null : ConvertPartialViewToString(controller.ControllerContext, pvr);
UmiWebSocketResponse result = new UmiWebSocketResponse
{
data = data,
error = null,
id = request.id,
timeStampSent = request.timeStampSent
};
Debug.WriteLine("Sent #{0} @{1} t:{2}", request.id, DateTime.Now,
Thread.CurrentThread.ManagedThreadId);
this.Send(JsonConvert.SerializeObject(result));
}
}
}
catch (Exception ex)
{
UmiWebSocketResponse errorResult = new UmiWebSocketResponse
{
error = ex.Message,
data = null,
id = request.id,
timeStampSent = request.timeStampSent
};
this.Send(JsonConvert.SerializeObject(errorResult));
}
}).Start();
}
private string ConvertPartialViewToString(ControllerContext controllerContext, PartialViewResult partialView)
{
using (var sw = new StringWriter())
{
partialView.View = ViewEngines.Engines
.FindPartialView(controllerContext, partialView.ViewName).View;
var vc = new ViewContext(
controllerContext, partialView.View, partialView.ViewData, partialView.TempData, sw);
partialView.View.Render(vc, sw);
var partialViewString = sw.GetStringBuilder().ToString();
return partialViewString;
}
}
}

my.infrastructure.webSocketHandler.send({ dataType: 'html', url: "/PartialViews/MyPartialView" }, function (result) { // do something with result });

my.infrastructure.useWebSocket = true;
my.infrastructure.webSocketHandler = (function () {
var uri = (location.protocol === "https:" ? "wss://" : "ws://").concat(window.location.hostname).concat("/api/reportsApi/GetQueryResultByWebSocket");
var requests = {
};
var counter = 0;
var websocket;
if (my.infrastructure.useWebSocket) {
websocket = new WebSocket(uri);
websocket.onopen = function () {
console.log("Connected to Web Socket");
};
websocket.onerror = function (event) {
console.log("ERROR CONNECTING TO WEB SOCKET");
};
websocket.onmessage = function (event) {
var message = JSON.parse(event.data);
message.timeStampReceived = new Date();
var id = message.id;
if (requests[id]) {
var request = requests[id];
console.log(message.timeStampReceived.toISOString() + ": Web Socket response received from " + request.request.url + " (queryName: " + (request.request.queryParams ? request.request.queryParams.queryName : "undefined") + "): "
//+ JSON.stringify(message)
);
if (message.Error) {
request.onError(message.error);
} else {
var data = message.data;
request.onSuccess(data);
}
delete requests[request[id]];
}
};
}
function sendRequest(settings, onSuccess, onError) {
if (!my.infrastructure.useWebSocket) {
// do some AJAX if asked for
}
var id = counter++;
var message = {
id: id,
queryParams: settings.data,
url: settings.url,
type: settings.type,
dataType: settings.dataType,
timeStampSent: new Date()
};
var messageStr = JSON.stringify(message);
requests[id] = {
onSuccess: onSuccess, onError: onError, request: message
};
waitForSocketConnection(websocket, function () {
console.log(message.timeStampSent.toISOString() + ": Web Socket message sent to " + settings.url + " (queryName: " + (message.queryParams ? message.queryParams.queryName : "undefined") + "): "
//+ messageStr
);
websocket.send(messageStr);
});
}
function abortAll() {
requests = {
};
}
function abortQuery(queryName) {
$.each(requests, function (index, request) {
if (request && request.request.queryName === queryName) {
delete requests[request[id]];
}
});
}
function waitForSocketConnection(socket, callback) {
var retryCounter = 3000; // 5 minutes
setTimeout(
function () {
if (socket.readyState === 1) {
if (callback != null) {
callback();
}
return;
} else {
if (retryCounter-- > 0) {
console.log("Waiting for Web Socket connection...");
waitForSocketConnection(socket, callback);
}
}
}, 100);
}
return {
send: sendRequest,
abortAll: abortAll,
abortQuery: abortQuery
}
})();

Looks like npm-check-updates is the only way to make this happen now.

npm i -g npm-check-updates
npm-check-updates -u
npm install

• Hosting: GoDaddy.com now (never again!!!), schnellnode.de (fantastically cheap, reliable and nice German hosting guys!)
• At least two parts: main site at seeyourtravel.com and corporate presence/contacts at seeyourtravel.com/corporate
• Facebook: facebook.com/seeyourtravel - just the must in today's world
• Twitter: twitter.com/seeyourtravel - be annoying enough!
• Blog: seeyourtravel.blogspot.com. Need to pay more time and attention to that yet!
• Analytics
• Google Analytics. Free and powerful. www.google.com/analytics/
• Clicky: clicky.com/
• YouTube: www.youtube.com/watch?v=2bSKNKqO2Uo
• Google+
• Feedback analysis from VisitorEngage.com

Thinking of:

• Flickr
• Instagram

• Leaflet and its plugins for maps: leafletjs.com/ ! Free, stable, and so pleaseant to use!
• i18next for translations. Nice!
• jstorage - good wrapper for HTML client storage stuff
• toastr - simply cool
• Carousels.... Still a tough question - looking for perfection.
• JQuery, JQuery UI and its plugins, and all the standard stuff

Integration libraries or Web API, to be moved to separate article: facebook, google, panoramio,

Congratulations!

Dear Mr. Turevskiy,

You have successfully passed the examination to ISTQB^® Certified Tester, Foundation Level.

You scored 35 out of 40 possible credits.

This equals 87,50%.

To pass the exam a minimum of 65% was necessary.

We wish you all the best for your professional future. The certificate will be issued and sent to you within four weeks after the examination fee has been paid. If you have paid by voucher or in advance the certificate will be issued and send to you within four weeks after the examination date.

Kind regards,

Your Certification team

• Training with Spider Project in Kiev, Ukraine (http://spiderproject.com.ua)
• PMI membership: pmi.org and my own PMBOK

Unexpectedly help comes from Microsoft Knowledge Base:

http://support.microsoft.com/kb/942055/

See case #9

http://learn.iis.net/page.aspx/145/how-to-use-locking-in-iis-70-configuration

Editing the %windir%\system32\inetsrv\config\applicationHost.config helped.

Error message:

HTTP Error 500.19 - Internal Server Error

The requested page cannot be accessed because the related configuration data for the page is invalid.

Detailed Error Information

netsh http add sslcert ipport=0.0.0.0:2202 certhash=ea81a9b4c330247f966d23d7e21266171f92cd47 appid={4EF5AB95-0A11-43b1-842C-51D56687CC7A}

Now need to understand - WHY??

However, there are kind people around!
Especially here:

So the reason was in pending after-reboot file copying requested (and never performed)

I believe this might cause some mistakes if you really have pending files, so make sure to reboot first.

Strangely :-), but Microsoft did it well:
http://blog.sqlauthority.com/2007/11/16/sql-server-2005-generate-script-with-data-from-database-database-publishing-wizard/

Visual Studio 2008 also have such tool built in.

(However I am not sure about complex databases (like encrypted) yet...)

Last Saturday (2009 July 25th) I've attended a quite funny event - PM Labs 2009 held by Luxoft Training Center, this year in Kiev. There way some issues, but generally it look like a most interesting PM community event in Ukraine - thanks Luxoft.

There was an assumption that it may be too headhunting-targeted, but it was rather an advvertisement of training center services those are not so imposing.

More info is here: http://www.pm-labs.ru/news/105

So let's go on!

Magic words are the command:
netsh http add urlacl url=http://+:9001/ user=DOMAIN\user
Replace URL and user domain/name with your data.

More details are here:
http://stackoverflow.com/questions/598643/hosting-a-wcf-service-in-vista
and here
http://msdn.microsoft.com/en-us/library/ms733768.aspx

By the way, thanks a lot for all the guys from http://stackoverflow.com/. Great job!

-------------------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.IO;
using System.ComponentModel;
using Microsoft.Win32.SafeHandles;
namespace MyCompany.MyProduct.Common.Win32
{
[Serializable]
public abstract class MyCompanyFileSystemInfo : MarshalByRefObject
{
const string UNC_PREFIX = "\\\\?\\UNC\\";
const string PREFIX = "\\\\?\\";
protected string _path;
protected WIN32_FILE_ATTRIBUTE_DATA _attributes;
protected bool _attributesNotFilled = false;
protected int _realPathStart;
int GetLastError()
{
return Marshal.GetLastWin32Error();
}
public string FullNameWithPrefix
{
get { return _path; }
}
public string FullName
{
get
{
//return _path.Substring(_realPathStart);
string t = _path;
if (t.StartsWith(UNC_PREFIX))
t = "\\\\" + t.Substring(UNC_PREFIX.Length);
else if (t.StartsWith(PREFIX))
t = t.Substring(PREFIX.Length);
return t;
}
}
public override string ToString()
{
return FullName;
}
public MyCompanyFileSystemInfo(string path)
{
path = path.TrimEnd('\\');
if (!path.StartsWith(PREFIX))
{
if (path.StartsWith("\\\\"))
{
// Unicode
path = UNC_PREFIX + path.TrimStart('\\');
_realPathStart = 8;
}
else
{
if (path[1] != ':')
{
if(path.StartsWith(".."))
{
path = Environment.CurrentDirectory.TrimEnd('\\') + "\\" + path.Substring(3);
}
else if (path.StartsWith("."))
{
path = Environment.CurrentDirectory.TrimEnd('\\') + "\\" + path.Substring(2);
}
}
// Local
path = PREFIX + path;
_realPathStart = 4;
}
}
_path = path;
FillAttributes();
}
private void FillAttributes()
{
if (!GetFileAttributesEx(_path, EFileInfoLevel.GetFileExInfoStandard, out _attributes))
_attributesNotFilled = true;
else
_attributesNotFilled = false;
}
public long Length
{
get
{
FillAttributes();
if (_attributesNotFilled)
throw new ApplicationException("File could not be opened");
long result = MakeLong(_attributes.fileSizeHigh, _attributes.fileSizeLow);
return result;
}
}
private long MakeLong(int high, int low)
{
return (((long)high) << result =" (EFileAttributes)_attributes.fileAttributes;" result =" DateTime.FromFileTime(MakeLong(" result =" DateTime.FromFileTime(MakeLong(" result =" DateTime.FromFileTime(MakeLong(" handle =" CreateFileInternal(" handle ="=" result =" false;" result =" true;" handle =" INVALID_HANDLE_VALUE;" handle =" CreateFile(" lastbslash =" _path.LastIndexOf('\\');">= _realPathStart)
{
string t = _path.Substring(0, lastBSlash).Substring(_realPathStart);
return new MyCompanyDirectoryInfo(t);
}
else
{
return null;
}
}
}
public string Name
{
get
{
string result = "";
int lastBSlash = _path.LastIndexOf('\\');
if (lastBSlash >= _realPathStart)
{
result = _path.Substring(lastBSlash+1);
}
else
{
result = _path.Substring(_realPathStart);
}
return result;
}
}
public abstract bool Delete();
#region API Wrappers
public static readonly IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);
[Flags]
public enum EFileAccess : uint
{
None = 0x0,
GenericRead = 0x80000000,
GenericWrite = 0x40000000,
GenericExecute = 0x20000000,
GenericAll = 0x10000000,
}
[Flags]
public enum EFileShare : uint
{
None = 0x00000000,
Read = 0x00000001,
Write = 0x00000002,
Delete = 0x00000004,
}
public enum ECreationDisposition : uint
{
New = 1,
CreateAlways = 2,
OpenExisting = 3,
OpenAlways = 4,
TruncateExisting = 5,
}
[Flags]
public enum EFileAttributes : uint
{
Readonly = 0x00000001,
Hidden = 0x00000002,
System = 0x00000004,
Directory = 0x00000010,
Archive = 0x00000020,
Device = 0x00000040,
Normal = 0x00000080,
Temporary = 0x00000100,
SparseFile = 0x00000200,
ReparsePoint = 0x00000400,
Compressed = 0x00000800,
Offline = 0x00001000,
NotContentIndexed = 0x00002000,
Encrypted = 0x00004000,
Write_Through = 0x80000000,
Overlapped = 0x40000000,
NoBuffering = 0x20000000,
RandomAccess = 0x10000000,
SequentialScan = 0x08000000,
DeleteOnClose = 0x04000000,
BackupSemantics = 0x02000000,
PosixSemantics = 0x01000000,
OpenReparsePoint = 0x00200000,
OpenNoRecall = 0x00100000,
FirstPipeInstance = 0x00080000
}
[DllImport("kernel32.dll", EntryPoint = "CreateFileW", SetLastError = true,
CharSet = CharSet.Unicode, ExactSpelling = true)]
public static extern IntPtr CreateFile(
string lpFileName,
EFileAccess dwDesiredAccess,
EFileShare dwShareMode,
IntPtr lpSecurityAttributes,
ECreationDisposition dwCreationDisposition,
EFileAttributes dwFlagsAndAttributes,
IntPtr hTemplateFile);
[StructLayout(LayoutKind.Sequential)]
public struct WIN32_FILE_ATTRIBUTE_DATA
{
public uint fileAttributes;
public System.Runtime.InteropServices.ComTypes.FILETIME creationTime;
public System.Runtime.InteropServices.ComTypes.FILETIME lastAccessTime;
public System.Runtime.InteropServices.ComTypes.FILETIME lastWriteTime;
public uint fileSizeHigh;
public uint fileSizeLow;
}
[DllImport("kernel32.dll", EntryPoint = "GetFileAttributesExW", SetLastError = true,
CharSet = CharSet.Unicode, ExactSpelling = true)]
public static extern bool GetFileAttributesEx
(string path, EFileInfoLevel level, out WIN32_FILE_ATTRIBUTE_DATA data);
[DllImport("kernel32.dll", EntryPoint = "CreateDirectoryExW", SetLastError = true,
CharSet = CharSet.Unicode, ExactSpelling = true)]
public static extern bool CreateDirectoryEx(string lpTemplateDirectory,
string lpNewDirectory, IntPtr lpSecurityAttributes);
public enum EFileInfoLevel : int
{
GetFileExInfoStandard = 0
}
public const int MAX_PATH = 260;
public const int MAX_ALTERNATE = 14;
[StructLayout(LayoutKind.Sequential, CharSet =
CharSet.Unicode)]
public struct WIN32_FIND_DATA
{
public EFileAttributes dwFileAttributes;
public System.Runtime.InteropServices.ComTypes.FILETIME ftCreationTime;
public System.Runtime.InteropServices.ComTypes.FILETIME ftLastAccessTime;
public System.Runtime.InteropServices.ComTypes.FILETIME ftLastWriteTime;
public int nFileSizeHigh;
public int nFileSizeLow;
public int dwReserved0;
public int dwReserved1;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH)]
public string cFileName;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_ALTERNATE)]
public string cAlternate;
}
[DllImport("kernel32", EntryPoint = "FindFirstFileW", SetLastError = true,
CharSet = CharSet.Unicode, ExactSpelling = true)]
public static extern IntPtr FindFirstFile(string lpFileName, out WIN32_FIND_DATA lpFindFileData);
[DllImport("kernel32", EntryPoint = "FindNextFileW", SetLastError = true,
CharSet = CharSet.Unicode, ExactSpelling = true)]
public static extern bool FindNextFile(IntPtr hFindFile, out WIN32_FIND_DATA lpFindFileData);
[DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
public static extern bool FindClose(IntPtr hFindFile);
[DllImport("kernel32.dll", EntryPoint = "RemoveDirectoryW", SetLastError = true,
CharSet = CharSet.Unicode, ExactSpelling = true)]
public static extern bool RemoveDirectory(string lpPathName);
[DllImport("kernel32.dll", EntryPoint = "DeleteFileW", SetLastError = true,
CharSet = CharSet.Unicode, ExactSpelling = true)]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool DeleteFile([MarshalAs(UnmanagedType.LPTStr)]string lpFileName);
[DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool CloseHandle(IntPtr hObject);
[DllImport("kernel32.dll", EntryPoint = "CopyFileW", SetLastError = true,
CharSet = CharSet.Auto, ExactSpelling = true)]
public static extern bool CopyFile(
String src, String dst, bool failIfExists);
#endregion
}
}

---------------------------------------------


using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.ComponentModel;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
namespace MyCompany.MyProduct.Common.Win32
{
public class MyCompanyDirectoryInfo : MyCompanyFileSystemInfo
{
public MyCompanyDirectoryInfo(string path) : base(path)
{
//if ((int)(Attributes & EFileAttributes.Directory) == 0)
// throw new ApplicationException("File path is specified. Use MyCompanyFileInfo instead");
}
public bool Create()
{
if (Exists)
return true;
if (Parent == null)
return true;
string t = Parent.FullNameWithPrefix;
if (t.EndsWith(":"))
t = Environment.SystemDirectory;
return CreateDirectoryEx(t, _path, new IntPtr());
}
public MyCompanyFileInfo[] GetFiles()
{
return GetFiles("*");
}
public MyCompanyDirectoryInfo[] GetDirectories()
{
return GetDirectories("*");
}
public MyCompanyFileInfo[] GetFiles(string pattern)
{
if (string.IsNullOrEmpty(pattern))
pattern = "*";
List _files = new List();
WIN32_FIND_DATA findData;
IntPtr findHandle;
findHandle = FindFirstFile(_path + @"\" + pattern, out findData);
if (findHandle != INVALID_HANDLE_VALUE)
{
do
{
if ((findData.dwFileAttributes & EFileAttributes.Directory) != 0)
{
}
else
{
string file = _path + @"\" + findData.cFileName;
_files.Add(new MyCompanyFileInfo(file));
}
}
while (FindNextFile(findHandle, out findData));
FindClose(findHandle);
}
return _files.ToArray();
}
public MyCompanyDirectoryInfo[] GetDirectories(string pattern)
{
if (string.IsNullOrEmpty(pattern))
pattern = "*";
List _folders = new List();
WIN32_FIND_DATA findData;
IntPtr findHandle;
findHandle = FindFirstFile(_path + @"\" + pattern, out findData);
if (findHandle != INVALID_HANDLE_VALUE)
{
do
{
if ((findData.dwFileAttributes & EFileAttributes.Directory) != 0)
{
if (findData.cFileName != "." && findData.cFileName != "..")
{
string subdirectory = _path + @"\" + findData.cFileName;
_folders.Add(new MyCompanyDirectoryInfo(subdirectory));
}
}
else
{
}
}
while (FindNextFile(findHandle, out findData));
FindClose(findHandle);
}
return _folders.ToArray();
}
public override bool Delete()
{
return RemoveDirectory(_path);
}
public bool Delete(bool recursively)
{
if (!recursively)
return Delete();
else
{
DeleteFilesAndFolders();
return Delete();
}
}
public void DeleteFilesAndFolders()
{
foreach (MyCompanyDirectoryInfo di in GetDirectories())
{
di.Delete(true);
}
foreach (MyCompanyFileInfo fi in GetFiles())
{
fi.Delete();
}
}
public bool Create(bool recursively)
{
if (recursively &&amp; Parent != null && !Parent.Exists)
Parent.Create(recursively);
bool b = Create();
return b;
}
public void CopyTo(MyCompanyDirectoryInfo dest, string pattern, bool recursively)
{
if (recursively)
{
foreach (MyCompanyDirectoryInfo di in GetDirectories(pattern))
{
MyCompanyDirectoryInfo di2 = new MyCompanyDirectoryInfo(dest.FullName + "\\" + di.Name);
di2.Create(true);
di.CopyTo(di2, pattern, true);
}
}
foreach (MyCompanyFileInfo fi in GetFiles(pattern))
{
MyCompanyFileInfo fi2 = new MyCompanyFileInfo(dest.FullName + "\\" + fi.Name);
fi.CopyTo(fi2, false);
}
}
}
}

----------------------------------------------------------------------------


using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.ComponentModel;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
namespace MyCompany.MyProduct.Common.Win32
{
public class MyCompanyFileInfo : MyCompanyFileSystemInfo
{
public MyCompanyFileInfo(string path) : base(path)
{
//if ((int)(Attributes & EFileAttributes.Directory) != 0)
// throw new ApplicationException("Directory path is specified. Use MyCompanyDirectoryInfo instead");
}
public FileStream Open(EFileAccess access,
EFileShare share,
ECreationDisposition creationDisposition,
EFileAttributes fileAttributes)
{
IntPtr handle = CreateFileInternal(access, share, creationDisposition, fileAttributes);
if (handle == INVALID_HANDLE_VALUE)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
else
{
return new FileStream(new SafeFileHandle(handle, true), FileAccess.ReadWrite);
}
}
public MyCompanyDirectoryInfo Directory
{
get
{
return Parent;
}
}
public FileStream OpenRead()
{
return Open(EFileAccess.GenericRead,EFileShare.Read,ECreationDisposition.OpenExisting,EFileAttributes.Normal);
}
public FileStream Create()
{
return Open(EFileAccess.GenericAll, EFileShare.None, ECreationDisposition.CreateAlways, EFileAttributes.Normal);
}
public FileStream OpenWrite()
{
return Open(EFileAccess.GenericWrite, EFileShare.None, ECreationDisposition.OpenAlways, EFileAttributes.Normal);
}
public override bool Delete()
{
return DeleteFile(_path);
}
internal void CopyTo(MyCompanyFileInfo fi2, bool failIfExists)
{
CopyFile(_path, fi2._path, failIfExists);
}
}
}