Code can be done in Mono (Linux) or .Net for Win32,
the code will run on both, as long as no win32 only classes are used.
Project is simple.
A c# program takes a jpg (or could be any file from command line) i.e.
sendpicture -u userid -t 1000 [url removed, login to view]
it then breaks the image up into parts and sends it to a server,
who is listening on a socket (this server part must be written too),
and reassembles the image and writes it to the file system, based
on info passed with the file i.e. the userid.
The -t option will just be a bit rate throttle, so lets say the image
is 100K bytes, and the -t 1000 means a 1000 byte/second transfer rate.
The client should thus only send the data no higher (and approx.) at the transfer rate given by the -t option.
There should be a setting that also determine the number of sub packets sent in 1 second,
So in our example, the 100K jpeg file, has a transfer target rate of
1000bytes/second. And we might say, we want 5 packets per second to
be sent, i.e. to have a more even transfer over the course of a second.
The client would then send 1000/5=200 bytes over the socket
in equal times, over 1 second, and do this until the entire file
has been sent. So in effect the client program will do a good job evenly metering out the file, as this will be used on a slow home network by people, and we don't want it to kill their voip phone
that might be used at the same time, thus we want to trickle out
the file data slowly, but have control over how slowly and the number of packets. The socket connection will be TCP, the port # can be picked from command line, else defaults to 9050
and the connection stays open the whole time as the file is being transfered, but an internal timer, will meter out the pieces of the file to stay within the -t #### throttle parameter. A program could also chose to do this in UDP, but a CRC routine would have to be used to assure no data corruption. The prgram should not BUSY WAIT between
packet sends, but rather sleep in a way that return process control
to other system tasks, this can be done by controlling how many
milliseconds needed to SLEEP between data sends.
At the server end, the file/image is reassembled, and written to the
filesystem, using a Path i.e. /home/storeimage/[url removed, login to view]
where YYMMDDHHMMSS is a simple (at server) use time stamp on the
Again , if one is more familiar with Win32, this could be done all on a win32 platform and tested, and will run on linux, provided standard socket/network, etc classes are used, and this could be specified to the programmer upon commencment. Again it needs to be done in c#.
The server has to be able to accept and recieve data from 100's of clients at the same time. And the server should not take up any access
cpu time then needed. A simple script loop (perl?) or a small test
program could test running 100 clients on a machine, all sending
data (a jpg) to the same server, in ordr to test the reliability
and performance of the server process, to be sure it works under load.
Some code can be supplied that listens and spwan a process to
deal with incoming data on a socket, etc, but this stuff is all pretty
common place type of code.
This project is certainly no more then a days job for someone who knows their stuff, and has done similar before, in fact could very well be under a days work.
There are other parts to this program, available upon sucessful